package com.sunny.fetch.pojo;

import java.util.ArrayList;
import java.util.List;

public class FBalancesheetExample {
    protected String orderByClause;

    protected boolean distinct;

    protected List<Criteria> oredCriteria;

    public FBalancesheetExample() {
        oredCriteria = new ArrayList<Criteria>();
    }

    public void setOrderByClause(String orderByClause) {
        this.orderByClause = orderByClause;
    }

    public String getOrderByClause() {
        return orderByClause;
    }

    public void setDistinct(boolean distinct) {
        this.distinct = distinct;
    }

    public boolean isDistinct() {
        return distinct;
    }

    public List<Criteria> getOredCriteria() {
        return oredCriteria;
    }

    public void or(Criteria criteria) {
        oredCriteria.add(criteria);
    }

    public Criteria or() {
        Criteria criteria = createCriteriaInternal();
        oredCriteria.add(criteria);
        return criteria;
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }
        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        Criteria criteria = new Criteria();
        return criteria;
    }

    public void clear() {
        oredCriteria.clear();
        orderByClause = null;
        distinct = false;
    }

    protected abstract static class GeneratedCriteria {
        protected List<Criterion> criteria;

        protected GeneratedCriteria() {
            super();
            criteria = new ArrayList<Criterion>();
        }

        public boolean isValid() {
            return criteria.size() > 0;
        }

        public List<Criterion> getAllCriteria() {
            return criteria;
        }

        public List<Criterion> getCriteria() {
            return criteria;
        }

        protected void addCriterion(String condition) {
            if (condition == null) {
                throw new RuntimeException("Value for condition cannot be null");
            }
            criteria.add(new Criterion(condition));
        }

        protected void addCriterion(String condition, Object value, String property) {
            if (value == null) {
                throw new RuntimeException("Value for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value));
        }

        protected void addCriterion(String condition, Object value1, Object value2, String property) {
            if (value1 == null || value2 == null) {
                throw new RuntimeException("Between values for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value1, value2));
        }

        public Criteria andTidIsNull() {
            addCriterion("tid is null");
            return (Criteria) this;
        }

        public Criteria andTidIsNotNull() {
            addCriterion("tid is not null");
            return (Criteria) this;
        }

        public Criteria andTidEqualTo(Long value) {
            addCriterion("tid =", value, "tid");
            return (Criteria) this;
        }

        public Criteria andTidNotEqualTo(Long value) {
            addCriterion("tid <>", value, "tid");
            return (Criteria) this;
        }

        public Criteria andTidGreaterThan(Long value) {
            addCriterion("tid >", value, "tid");
            return (Criteria) this;
        }

        public Criteria andTidGreaterThanOrEqualTo(Long value) {
            addCriterion("tid >=", value, "tid");
            return (Criteria) this;
        }

        public Criteria andTidLessThan(Long value) {
            addCriterion("tid <", value, "tid");
            return (Criteria) this;
        }

        public Criteria andTidLessThanOrEqualTo(Long value) {
            addCriterion("tid <=", value, "tid");
            return (Criteria) this;
        }

        public Criteria andTidIn(List<Long> values) {
            addCriterion("tid in", values, "tid");
            return (Criteria) this;
        }

        public Criteria andTidNotIn(List<Long> values) {
            addCriterion("tid not in", values, "tid");
            return (Criteria) this;
        }

        public Criteria andTidBetween(Long value1, Long value2) {
            addCriterion("tid between", value1, value2, "tid");
            return (Criteria) this;
        }

        public Criteria andTidNotBetween(Long value1, Long value2) {
            addCriterion("tid not between", value1, value2, "tid");
            return (Criteria) this;
        }

        public Criteria andTsCodeIsNull() {
            addCriterion("ts_code is null");
            return (Criteria) this;
        }

        public Criteria andTsCodeIsNotNull() {
            addCriterion("ts_code is not null");
            return (Criteria) this;
        }

        public Criteria andTsCodeEqualTo(String value) {
            addCriterion("ts_code =", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeNotEqualTo(String value) {
            addCriterion("ts_code <>", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeGreaterThan(String value) {
            addCriterion("ts_code >", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeGreaterThanOrEqualTo(String value) {
            addCriterion("ts_code >=", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeLessThan(String value) {
            addCriterion("ts_code <", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeLessThanOrEqualTo(String value) {
            addCriterion("ts_code <=", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeLike(String value) {
            addCriterion("ts_code like", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeNotLike(String value) {
            addCriterion("ts_code not like", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeIn(List<String> values) {
            addCriterion("ts_code in", values, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeNotIn(List<String> values) {
            addCriterion("ts_code not in", values, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeBetween(String value1, String value2) {
            addCriterion("ts_code between", value1, value2, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeNotBetween(String value1, String value2) {
            addCriterion("ts_code not between", value1, value2, "tsCode");
            return (Criteria) this;
        }

        public Criteria andAnnDateIsNull() {
            addCriterion("ann_date is null");
            return (Criteria) this;
        }

        public Criteria andAnnDateIsNotNull() {
            addCriterion("ann_date is not null");
            return (Criteria) this;
        }

        public Criteria andAnnDateEqualTo(String value) {
            addCriterion("ann_date =", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateNotEqualTo(String value) {
            addCriterion("ann_date <>", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateGreaterThan(String value) {
            addCriterion("ann_date >", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateGreaterThanOrEqualTo(String value) {
            addCriterion("ann_date >=", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateLessThan(String value) {
            addCriterion("ann_date <", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateLessThanOrEqualTo(String value) {
            addCriterion("ann_date <=", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateLike(String value) {
            addCriterion("ann_date like", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateNotLike(String value) {
            addCriterion("ann_date not like", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateIn(List<String> values) {
            addCriterion("ann_date in", values, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateNotIn(List<String> values) {
            addCriterion("ann_date not in", values, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateBetween(String value1, String value2) {
            addCriterion("ann_date between", value1, value2, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateNotBetween(String value1, String value2) {
            addCriterion("ann_date not between", value1, value2, "annDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateIsNull() {
            addCriterion("f_ann_date is null");
            return (Criteria) this;
        }

        public Criteria andFAnnDateIsNotNull() {
            addCriterion("f_ann_date is not null");
            return (Criteria) this;
        }

        public Criteria andFAnnDateEqualTo(String value) {
            addCriterion("f_ann_date =", value, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateNotEqualTo(String value) {
            addCriterion("f_ann_date <>", value, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateGreaterThan(String value) {
            addCriterion("f_ann_date >", value, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateGreaterThanOrEqualTo(String value) {
            addCriterion("f_ann_date >=", value, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateLessThan(String value) {
            addCriterion("f_ann_date <", value, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateLessThanOrEqualTo(String value) {
            addCriterion("f_ann_date <=", value, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateLike(String value) {
            addCriterion("f_ann_date like", value, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateNotLike(String value) {
            addCriterion("f_ann_date not like", value, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateIn(List<String> values) {
            addCriterion("f_ann_date in", values, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateNotIn(List<String> values) {
            addCriterion("f_ann_date not in", values, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateBetween(String value1, String value2) {
            addCriterion("f_ann_date between", value1, value2, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateNotBetween(String value1, String value2) {
            addCriterion("f_ann_date not between", value1, value2, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andEndDateIsNull() {
            addCriterion("end_date is null");
            return (Criteria) this;
        }

        public Criteria andEndDateIsNotNull() {
            addCriterion("end_date is not null");
            return (Criteria) this;
        }

        public Criteria andEndDateEqualTo(String value) {
            addCriterion("end_date =", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateNotEqualTo(String value) {
            addCriterion("end_date <>", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateGreaterThan(String value) {
            addCriterion("end_date >", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateGreaterThanOrEqualTo(String value) {
            addCriterion("end_date >=", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateLessThan(String value) {
            addCriterion("end_date <", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateLessThanOrEqualTo(String value) {
            addCriterion("end_date <=", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateLike(String value) {
            addCriterion("end_date like", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateNotLike(String value) {
            addCriterion("end_date not like", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateIn(List<String> values) {
            addCriterion("end_date in", values, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateNotIn(List<String> values) {
            addCriterion("end_date not in", values, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateBetween(String value1, String value2) {
            addCriterion("end_date between", value1, value2, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateNotBetween(String value1, String value2) {
            addCriterion("end_date not between", value1, value2, "endDate");
            return (Criteria) this;
        }

        public Criteria andReportTypeIsNull() {
            addCriterion("report_type is null");
            return (Criteria) this;
        }

        public Criteria andReportTypeIsNotNull() {
            addCriterion("report_type is not null");
            return (Criteria) this;
        }

        public Criteria andReportTypeEqualTo(String value) {
            addCriterion("report_type =", value, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeNotEqualTo(String value) {
            addCriterion("report_type <>", value, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeGreaterThan(String value) {
            addCriterion("report_type >", value, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeGreaterThanOrEqualTo(String value) {
            addCriterion("report_type >=", value, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeLessThan(String value) {
            addCriterion("report_type <", value, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeLessThanOrEqualTo(String value) {
            addCriterion("report_type <=", value, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeLike(String value) {
            addCriterion("report_type like", value, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeNotLike(String value) {
            addCriterion("report_type not like", value, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeIn(List<String> values) {
            addCriterion("report_type in", values, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeNotIn(List<String> values) {
            addCriterion("report_type not in", values, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeBetween(String value1, String value2) {
            addCriterion("report_type between", value1, value2, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeNotBetween(String value1, String value2) {
            addCriterion("report_type not between", value1, value2, "reportType");
            return (Criteria) this;
        }

        public Criteria andCompTypeIsNull() {
            addCriterion("comp_type is null");
            return (Criteria) this;
        }

        public Criteria andCompTypeIsNotNull() {
            addCriterion("comp_type is not null");
            return (Criteria) this;
        }

        public Criteria andCompTypeEqualTo(String value) {
            addCriterion("comp_type =", value, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeNotEqualTo(String value) {
            addCriterion("comp_type <>", value, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeGreaterThan(String value) {
            addCriterion("comp_type >", value, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeGreaterThanOrEqualTo(String value) {
            addCriterion("comp_type >=", value, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeLessThan(String value) {
            addCriterion("comp_type <", value, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeLessThanOrEqualTo(String value) {
            addCriterion("comp_type <=", value, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeLike(String value) {
            addCriterion("comp_type like", value, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeNotLike(String value) {
            addCriterion("comp_type not like", value, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeIn(List<String> values) {
            addCriterion("comp_type in", values, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeNotIn(List<String> values) {
            addCriterion("comp_type not in", values, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeBetween(String value1, String value2) {
            addCriterion("comp_type between", value1, value2, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeNotBetween(String value1, String value2) {
            addCriterion("comp_type not between", value1, value2, "compType");
            return (Criteria) this;
        }

        public Criteria andTotalShareIsNull() {
            addCriterion("total_share is null");
            return (Criteria) this;
        }

        public Criteria andTotalShareIsNotNull() {
            addCriterion("total_share is not null");
            return (Criteria) this;
        }

        public Criteria andTotalShareEqualTo(Float value) {
            addCriterion("total_share =", value, "totalShare");
            return (Criteria) this;
        }

        public Criteria andTotalShareNotEqualTo(Float value) {
            addCriterion("total_share <>", value, "totalShare");
            return (Criteria) this;
        }

        public Criteria andTotalShareGreaterThan(Float value) {
            addCriterion("total_share >", value, "totalShare");
            return (Criteria) this;
        }

        public Criteria andTotalShareGreaterThanOrEqualTo(Float value) {
            addCriterion("total_share >=", value, "totalShare");
            return (Criteria) this;
        }

        public Criteria andTotalShareLessThan(Float value) {
            addCriterion("total_share <", value, "totalShare");
            return (Criteria) this;
        }

        public Criteria andTotalShareLessThanOrEqualTo(Float value) {
            addCriterion("total_share <=", value, "totalShare");
            return (Criteria) this;
        }

        public Criteria andTotalShareIn(List<Float> values) {
            addCriterion("total_share in", values, "totalShare");
            return (Criteria) this;
        }

        public Criteria andTotalShareNotIn(List<Float> values) {
            addCriterion("total_share not in", values, "totalShare");
            return (Criteria) this;
        }

        public Criteria andTotalShareBetween(Float value1, Float value2) {
            addCriterion("total_share between", value1, value2, "totalShare");
            return (Criteria) this;
        }

        public Criteria andTotalShareNotBetween(Float value1, Float value2) {
            addCriterion("total_share not between", value1, value2, "totalShare");
            return (Criteria) this;
        }

        public Criteria andCapReseIsNull() {
            addCriterion("cap_rese is null");
            return (Criteria) this;
        }

        public Criteria andCapReseIsNotNull() {
            addCriterion("cap_rese is not null");
            return (Criteria) this;
        }

        public Criteria andCapReseEqualTo(Float value) {
            addCriterion("cap_rese =", value, "capRese");
            return (Criteria) this;
        }

        public Criteria andCapReseNotEqualTo(Float value) {
            addCriterion("cap_rese <>", value, "capRese");
            return (Criteria) this;
        }

        public Criteria andCapReseGreaterThan(Float value) {
            addCriterion("cap_rese >", value, "capRese");
            return (Criteria) this;
        }

        public Criteria andCapReseGreaterThanOrEqualTo(Float value) {
            addCriterion("cap_rese >=", value, "capRese");
            return (Criteria) this;
        }

        public Criteria andCapReseLessThan(Float value) {
            addCriterion("cap_rese <", value, "capRese");
            return (Criteria) this;
        }

        public Criteria andCapReseLessThanOrEqualTo(Float value) {
            addCriterion("cap_rese <=", value, "capRese");
            return (Criteria) this;
        }

        public Criteria andCapReseIn(List<Float> values) {
            addCriterion("cap_rese in", values, "capRese");
            return (Criteria) this;
        }

        public Criteria andCapReseNotIn(List<Float> values) {
            addCriterion("cap_rese not in", values, "capRese");
            return (Criteria) this;
        }

        public Criteria andCapReseBetween(Float value1, Float value2) {
            addCriterion("cap_rese between", value1, value2, "capRese");
            return (Criteria) this;
        }

        public Criteria andCapReseNotBetween(Float value1, Float value2) {
            addCriterion("cap_rese not between", value1, value2, "capRese");
            return (Criteria) this;
        }

        public Criteria andUndistrPorfitIsNull() {
            addCriterion("undistr_porfit is null");
            return (Criteria) this;
        }

        public Criteria andUndistrPorfitIsNotNull() {
            addCriterion("undistr_porfit is not null");
            return (Criteria) this;
        }

        public Criteria andUndistrPorfitEqualTo(Float value) {
            addCriterion("undistr_porfit =", value, "undistrPorfit");
            return (Criteria) this;
        }

        public Criteria andUndistrPorfitNotEqualTo(Float value) {
            addCriterion("undistr_porfit <>", value, "undistrPorfit");
            return (Criteria) this;
        }

        public Criteria andUndistrPorfitGreaterThan(Float value) {
            addCriterion("undistr_porfit >", value, "undistrPorfit");
            return (Criteria) this;
        }

        public Criteria andUndistrPorfitGreaterThanOrEqualTo(Float value) {
            addCriterion("undistr_porfit >=", value, "undistrPorfit");
            return (Criteria) this;
        }

        public Criteria andUndistrPorfitLessThan(Float value) {
            addCriterion("undistr_porfit <", value, "undistrPorfit");
            return (Criteria) this;
        }

        public Criteria andUndistrPorfitLessThanOrEqualTo(Float value) {
            addCriterion("undistr_porfit <=", value, "undistrPorfit");
            return (Criteria) this;
        }

        public Criteria andUndistrPorfitIn(List<Float> values) {
            addCriterion("undistr_porfit in", values, "undistrPorfit");
            return (Criteria) this;
        }

        public Criteria andUndistrPorfitNotIn(List<Float> values) {
            addCriterion("undistr_porfit not in", values, "undistrPorfit");
            return (Criteria) this;
        }

        public Criteria andUndistrPorfitBetween(Float value1, Float value2) {
            addCriterion("undistr_porfit between", value1, value2, "undistrPorfit");
            return (Criteria) this;
        }

        public Criteria andUndistrPorfitNotBetween(Float value1, Float value2) {
            addCriterion("undistr_porfit not between", value1, value2, "undistrPorfit");
            return (Criteria) this;
        }

        public Criteria andSurplusReseIsNull() {
            addCriterion("surplus_rese is null");
            return (Criteria) this;
        }

        public Criteria andSurplusReseIsNotNull() {
            addCriterion("surplus_rese is not null");
            return (Criteria) this;
        }

        public Criteria andSurplusReseEqualTo(Float value) {
            addCriterion("surplus_rese =", value, "surplusRese");
            return (Criteria) this;
        }

        public Criteria andSurplusReseNotEqualTo(Float value) {
            addCriterion("surplus_rese <>", value, "surplusRese");
            return (Criteria) this;
        }

        public Criteria andSurplusReseGreaterThan(Float value) {
            addCriterion("surplus_rese >", value, "surplusRese");
            return (Criteria) this;
        }

        public Criteria andSurplusReseGreaterThanOrEqualTo(Float value) {
            addCriterion("surplus_rese >=", value, "surplusRese");
            return (Criteria) this;
        }

        public Criteria andSurplusReseLessThan(Float value) {
            addCriterion("surplus_rese <", value, "surplusRese");
            return (Criteria) this;
        }

        public Criteria andSurplusReseLessThanOrEqualTo(Float value) {
            addCriterion("surplus_rese <=", value, "surplusRese");
            return (Criteria) this;
        }

        public Criteria andSurplusReseIn(List<Float> values) {
            addCriterion("surplus_rese in", values, "surplusRese");
            return (Criteria) this;
        }

        public Criteria andSurplusReseNotIn(List<Float> values) {
            addCriterion("surplus_rese not in", values, "surplusRese");
            return (Criteria) this;
        }

        public Criteria andSurplusReseBetween(Float value1, Float value2) {
            addCriterion("surplus_rese between", value1, value2, "surplusRese");
            return (Criteria) this;
        }

        public Criteria andSurplusReseNotBetween(Float value1, Float value2) {
            addCriterion("surplus_rese not between", value1, value2, "surplusRese");
            return (Criteria) this;
        }

        public Criteria andSpecialReseIsNull() {
            addCriterion("special_rese is null");
            return (Criteria) this;
        }

        public Criteria andSpecialReseIsNotNull() {
            addCriterion("special_rese is not null");
            return (Criteria) this;
        }

        public Criteria andSpecialReseEqualTo(Float value) {
            addCriterion("special_rese =", value, "specialRese");
            return (Criteria) this;
        }

        public Criteria andSpecialReseNotEqualTo(Float value) {
            addCriterion("special_rese <>", value, "specialRese");
            return (Criteria) this;
        }

        public Criteria andSpecialReseGreaterThan(Float value) {
            addCriterion("special_rese >", value, "specialRese");
            return (Criteria) this;
        }

        public Criteria andSpecialReseGreaterThanOrEqualTo(Float value) {
            addCriterion("special_rese >=", value, "specialRese");
            return (Criteria) this;
        }

        public Criteria andSpecialReseLessThan(Float value) {
            addCriterion("special_rese <", value, "specialRese");
            return (Criteria) this;
        }

        public Criteria andSpecialReseLessThanOrEqualTo(Float value) {
            addCriterion("special_rese <=", value, "specialRese");
            return (Criteria) this;
        }

        public Criteria andSpecialReseIn(List<Float> values) {
            addCriterion("special_rese in", values, "specialRese");
            return (Criteria) this;
        }

        public Criteria andSpecialReseNotIn(List<Float> values) {
            addCriterion("special_rese not in", values, "specialRese");
            return (Criteria) this;
        }

        public Criteria andSpecialReseBetween(Float value1, Float value2) {
            addCriterion("special_rese between", value1, value2, "specialRese");
            return (Criteria) this;
        }

        public Criteria andSpecialReseNotBetween(Float value1, Float value2) {
            addCriterion("special_rese not between", value1, value2, "specialRese");
            return (Criteria) this;
        }

        public Criteria andMoneyCapIsNull() {
            addCriterion("money_cap is null");
            return (Criteria) this;
        }

        public Criteria andMoneyCapIsNotNull() {
            addCriterion("money_cap is not null");
            return (Criteria) this;
        }

        public Criteria andMoneyCapEqualTo(Float value) {
            addCriterion("money_cap =", value, "moneyCap");
            return (Criteria) this;
        }

        public Criteria andMoneyCapNotEqualTo(Float value) {
            addCriterion("money_cap <>", value, "moneyCap");
            return (Criteria) this;
        }

        public Criteria andMoneyCapGreaterThan(Float value) {
            addCriterion("money_cap >", value, "moneyCap");
            return (Criteria) this;
        }

        public Criteria andMoneyCapGreaterThanOrEqualTo(Float value) {
            addCriterion("money_cap >=", value, "moneyCap");
            return (Criteria) this;
        }

        public Criteria andMoneyCapLessThan(Float value) {
            addCriterion("money_cap <", value, "moneyCap");
            return (Criteria) this;
        }

        public Criteria andMoneyCapLessThanOrEqualTo(Float value) {
            addCriterion("money_cap <=", value, "moneyCap");
            return (Criteria) this;
        }

        public Criteria andMoneyCapIn(List<Float> values) {
            addCriterion("money_cap in", values, "moneyCap");
            return (Criteria) this;
        }

        public Criteria andMoneyCapNotIn(List<Float> values) {
            addCriterion("money_cap not in", values, "moneyCap");
            return (Criteria) this;
        }

        public Criteria andMoneyCapBetween(Float value1, Float value2) {
            addCriterion("money_cap between", value1, value2, "moneyCap");
            return (Criteria) this;
        }

        public Criteria andMoneyCapNotBetween(Float value1, Float value2) {
            addCriterion("money_cap not between", value1, value2, "moneyCap");
            return (Criteria) this;
        }

        public Criteria andTradAssetIsNull() {
            addCriterion("trad_asset is null");
            return (Criteria) this;
        }

        public Criteria andTradAssetIsNotNull() {
            addCriterion("trad_asset is not null");
            return (Criteria) this;
        }

        public Criteria andTradAssetEqualTo(Float value) {
            addCriterion("trad_asset =", value, "tradAsset");
            return (Criteria) this;
        }

        public Criteria andTradAssetNotEqualTo(Float value) {
            addCriterion("trad_asset <>", value, "tradAsset");
            return (Criteria) this;
        }

        public Criteria andTradAssetGreaterThan(Float value) {
            addCriterion("trad_asset >", value, "tradAsset");
            return (Criteria) this;
        }

        public Criteria andTradAssetGreaterThanOrEqualTo(Float value) {
            addCriterion("trad_asset >=", value, "tradAsset");
            return (Criteria) this;
        }

        public Criteria andTradAssetLessThan(Float value) {
            addCriterion("trad_asset <", value, "tradAsset");
            return (Criteria) this;
        }

        public Criteria andTradAssetLessThanOrEqualTo(Float value) {
            addCriterion("trad_asset <=", value, "tradAsset");
            return (Criteria) this;
        }

        public Criteria andTradAssetIn(List<Float> values) {
            addCriterion("trad_asset in", values, "tradAsset");
            return (Criteria) this;
        }

        public Criteria andTradAssetNotIn(List<Float> values) {
            addCriterion("trad_asset not in", values, "tradAsset");
            return (Criteria) this;
        }

        public Criteria andTradAssetBetween(Float value1, Float value2) {
            addCriterion("trad_asset between", value1, value2, "tradAsset");
            return (Criteria) this;
        }

        public Criteria andTradAssetNotBetween(Float value1, Float value2) {
            addCriterion("trad_asset not between", value1, value2, "tradAsset");
            return (Criteria) this;
        }

        public Criteria andNotesReceivIsNull() {
            addCriterion("notes_receiv is null");
            return (Criteria) this;
        }

        public Criteria andNotesReceivIsNotNull() {
            addCriterion("notes_receiv is not null");
            return (Criteria) this;
        }

        public Criteria andNotesReceivEqualTo(Float value) {
            addCriterion("notes_receiv =", value, "notesReceiv");
            return (Criteria) this;
        }

        public Criteria andNotesReceivNotEqualTo(Float value) {
            addCriterion("notes_receiv <>", value, "notesReceiv");
            return (Criteria) this;
        }

        public Criteria andNotesReceivGreaterThan(Float value) {
            addCriterion("notes_receiv >", value, "notesReceiv");
            return (Criteria) this;
        }

        public Criteria andNotesReceivGreaterThanOrEqualTo(Float value) {
            addCriterion("notes_receiv >=", value, "notesReceiv");
            return (Criteria) this;
        }

        public Criteria andNotesReceivLessThan(Float value) {
            addCriterion("notes_receiv <", value, "notesReceiv");
            return (Criteria) this;
        }

        public Criteria andNotesReceivLessThanOrEqualTo(Float value) {
            addCriterion("notes_receiv <=", value, "notesReceiv");
            return (Criteria) this;
        }

        public Criteria andNotesReceivIn(List<Float> values) {
            addCriterion("notes_receiv in", values, "notesReceiv");
            return (Criteria) this;
        }

        public Criteria andNotesReceivNotIn(List<Float> values) {
            addCriterion("notes_receiv not in", values, "notesReceiv");
            return (Criteria) this;
        }

        public Criteria andNotesReceivBetween(Float value1, Float value2) {
            addCriterion("notes_receiv between", value1, value2, "notesReceiv");
            return (Criteria) this;
        }

        public Criteria andNotesReceivNotBetween(Float value1, Float value2) {
            addCriterion("notes_receiv not between", value1, value2, "notesReceiv");
            return (Criteria) this;
        }

        public Criteria andAccountsReceivIsNull() {
            addCriterion("accounts_receiv is null");
            return (Criteria) this;
        }

        public Criteria andAccountsReceivIsNotNull() {
            addCriterion("accounts_receiv is not null");
            return (Criteria) this;
        }

        public Criteria andAccountsReceivEqualTo(Float value) {
            addCriterion("accounts_receiv =", value, "accountsReceiv");
            return (Criteria) this;
        }

        public Criteria andAccountsReceivNotEqualTo(Float value) {
            addCriterion("accounts_receiv <>", value, "accountsReceiv");
            return (Criteria) this;
        }

        public Criteria andAccountsReceivGreaterThan(Float value) {
            addCriterion("accounts_receiv >", value, "accountsReceiv");
            return (Criteria) this;
        }

        public Criteria andAccountsReceivGreaterThanOrEqualTo(Float value) {
            addCriterion("accounts_receiv >=", value, "accountsReceiv");
            return (Criteria) this;
        }

        public Criteria andAccountsReceivLessThan(Float value) {
            addCriterion("accounts_receiv <", value, "accountsReceiv");
            return (Criteria) this;
        }

        public Criteria andAccountsReceivLessThanOrEqualTo(Float value) {
            addCriterion("accounts_receiv <=", value, "accountsReceiv");
            return (Criteria) this;
        }

        public Criteria andAccountsReceivIn(List<Float> values) {
            addCriterion("accounts_receiv in", values, "accountsReceiv");
            return (Criteria) this;
        }

        public Criteria andAccountsReceivNotIn(List<Float> values) {
            addCriterion("accounts_receiv not in", values, "accountsReceiv");
            return (Criteria) this;
        }

        public Criteria andAccountsReceivBetween(Float value1, Float value2) {
            addCriterion("accounts_receiv between", value1, value2, "accountsReceiv");
            return (Criteria) this;
        }

        public Criteria andAccountsReceivNotBetween(Float value1, Float value2) {
            addCriterion("accounts_receiv not between", value1, value2, "accountsReceiv");
            return (Criteria) this;
        }

        public Criteria andOthReceivIsNull() {
            addCriterion("oth_receiv is null");
            return (Criteria) this;
        }

        public Criteria andOthReceivIsNotNull() {
            addCriterion("oth_receiv is not null");
            return (Criteria) this;
        }

        public Criteria andOthReceivEqualTo(Float value) {
            addCriterion("oth_receiv =", value, "othReceiv");
            return (Criteria) this;
        }

        public Criteria andOthReceivNotEqualTo(Float value) {
            addCriterion("oth_receiv <>", value, "othReceiv");
            return (Criteria) this;
        }

        public Criteria andOthReceivGreaterThan(Float value) {
            addCriterion("oth_receiv >", value, "othReceiv");
            return (Criteria) this;
        }

        public Criteria andOthReceivGreaterThanOrEqualTo(Float value) {
            addCriterion("oth_receiv >=", value, "othReceiv");
            return (Criteria) this;
        }

        public Criteria andOthReceivLessThan(Float value) {
            addCriterion("oth_receiv <", value, "othReceiv");
            return (Criteria) this;
        }

        public Criteria andOthReceivLessThanOrEqualTo(Float value) {
            addCriterion("oth_receiv <=", value, "othReceiv");
            return (Criteria) this;
        }

        public Criteria andOthReceivIn(List<Float> values) {
            addCriterion("oth_receiv in", values, "othReceiv");
            return (Criteria) this;
        }

        public Criteria andOthReceivNotIn(List<Float> values) {
            addCriterion("oth_receiv not in", values, "othReceiv");
            return (Criteria) this;
        }

        public Criteria andOthReceivBetween(Float value1, Float value2) {
            addCriterion("oth_receiv between", value1, value2, "othReceiv");
            return (Criteria) this;
        }

        public Criteria andOthReceivNotBetween(Float value1, Float value2) {
            addCriterion("oth_receiv not between", value1, value2, "othReceiv");
            return (Criteria) this;
        }

        public Criteria andPrepaymentIsNull() {
            addCriterion("prepayment is null");
            return (Criteria) this;
        }

        public Criteria andPrepaymentIsNotNull() {
            addCriterion("prepayment is not null");
            return (Criteria) this;
        }

        public Criteria andPrepaymentEqualTo(Float value) {
            addCriterion("prepayment =", value, "prepayment");
            return (Criteria) this;
        }

        public Criteria andPrepaymentNotEqualTo(Float value) {
            addCriterion("prepayment <>", value, "prepayment");
            return (Criteria) this;
        }

        public Criteria andPrepaymentGreaterThan(Float value) {
            addCriterion("prepayment >", value, "prepayment");
            return (Criteria) this;
        }

        public Criteria andPrepaymentGreaterThanOrEqualTo(Float value) {
            addCriterion("prepayment >=", value, "prepayment");
            return (Criteria) this;
        }

        public Criteria andPrepaymentLessThan(Float value) {
            addCriterion("prepayment <", value, "prepayment");
            return (Criteria) this;
        }

        public Criteria andPrepaymentLessThanOrEqualTo(Float value) {
            addCriterion("prepayment <=", value, "prepayment");
            return (Criteria) this;
        }

        public Criteria andPrepaymentIn(List<Float> values) {
            addCriterion("prepayment in", values, "prepayment");
            return (Criteria) this;
        }

        public Criteria andPrepaymentNotIn(List<Float> values) {
            addCriterion("prepayment not in", values, "prepayment");
            return (Criteria) this;
        }

        public Criteria andPrepaymentBetween(Float value1, Float value2) {
            addCriterion("prepayment between", value1, value2, "prepayment");
            return (Criteria) this;
        }

        public Criteria andPrepaymentNotBetween(Float value1, Float value2) {
            addCriterion("prepayment not between", value1, value2, "prepayment");
            return (Criteria) this;
        }

        public Criteria andDivReceivIsNull() {
            addCriterion("div_receiv is null");
            return (Criteria) this;
        }

        public Criteria andDivReceivIsNotNull() {
            addCriterion("div_receiv is not null");
            return (Criteria) this;
        }

        public Criteria andDivReceivEqualTo(Float value) {
            addCriterion("div_receiv =", value, "divReceiv");
            return (Criteria) this;
        }

        public Criteria andDivReceivNotEqualTo(Float value) {
            addCriterion("div_receiv <>", value, "divReceiv");
            return (Criteria) this;
        }

        public Criteria andDivReceivGreaterThan(Float value) {
            addCriterion("div_receiv >", value, "divReceiv");
            return (Criteria) this;
        }

        public Criteria andDivReceivGreaterThanOrEqualTo(Float value) {
            addCriterion("div_receiv >=", value, "divReceiv");
            return (Criteria) this;
        }

        public Criteria andDivReceivLessThan(Float value) {
            addCriterion("div_receiv <", value, "divReceiv");
            return (Criteria) this;
        }

        public Criteria andDivReceivLessThanOrEqualTo(Float value) {
            addCriterion("div_receiv <=", value, "divReceiv");
            return (Criteria) this;
        }

        public Criteria andDivReceivIn(List<Float> values) {
            addCriterion("div_receiv in", values, "divReceiv");
            return (Criteria) this;
        }

        public Criteria andDivReceivNotIn(List<Float> values) {
            addCriterion("div_receiv not in", values, "divReceiv");
            return (Criteria) this;
        }

        public Criteria andDivReceivBetween(Float value1, Float value2) {
            addCriterion("div_receiv between", value1, value2, "divReceiv");
            return (Criteria) this;
        }

        public Criteria andDivReceivNotBetween(Float value1, Float value2) {
            addCriterion("div_receiv not between", value1, value2, "divReceiv");
            return (Criteria) this;
        }

        public Criteria andIntReceivIsNull() {
            addCriterion("int_receiv is null");
            return (Criteria) this;
        }

        public Criteria andIntReceivIsNotNull() {
            addCriterion("int_receiv is not null");
            return (Criteria) this;
        }

        public Criteria andIntReceivEqualTo(Float value) {
            addCriterion("int_receiv =", value, "intReceiv");
            return (Criteria) this;
        }

        public Criteria andIntReceivNotEqualTo(Float value) {
            addCriterion("int_receiv <>", value, "intReceiv");
            return (Criteria) this;
        }

        public Criteria andIntReceivGreaterThan(Float value) {
            addCriterion("int_receiv >", value, "intReceiv");
            return (Criteria) this;
        }

        public Criteria andIntReceivGreaterThanOrEqualTo(Float value) {
            addCriterion("int_receiv >=", value, "intReceiv");
            return (Criteria) this;
        }

        public Criteria andIntReceivLessThan(Float value) {
            addCriterion("int_receiv <", value, "intReceiv");
            return (Criteria) this;
        }

        public Criteria andIntReceivLessThanOrEqualTo(Float value) {
            addCriterion("int_receiv <=", value, "intReceiv");
            return (Criteria) this;
        }

        public Criteria andIntReceivIn(List<Float> values) {
            addCriterion("int_receiv in", values, "intReceiv");
            return (Criteria) this;
        }

        public Criteria andIntReceivNotIn(List<Float> values) {
            addCriterion("int_receiv not in", values, "intReceiv");
            return (Criteria) this;
        }

        public Criteria andIntReceivBetween(Float value1, Float value2) {
            addCriterion("int_receiv between", value1, value2, "intReceiv");
            return (Criteria) this;
        }

        public Criteria andIntReceivNotBetween(Float value1, Float value2) {
            addCriterion("int_receiv not between", value1, value2, "intReceiv");
            return (Criteria) this;
        }

        public Criteria andInventoriesIsNull() {
            addCriterion("inventories is null");
            return (Criteria) this;
        }

        public Criteria andInventoriesIsNotNull() {
            addCriterion("inventories is not null");
            return (Criteria) this;
        }

        public Criteria andInventoriesEqualTo(Float value) {
            addCriterion("inventories =", value, "inventories");
            return (Criteria) this;
        }

        public Criteria andInventoriesNotEqualTo(Float value) {
            addCriterion("inventories <>", value, "inventories");
            return (Criteria) this;
        }

        public Criteria andInventoriesGreaterThan(Float value) {
            addCriterion("inventories >", value, "inventories");
            return (Criteria) this;
        }

        public Criteria andInventoriesGreaterThanOrEqualTo(Float value) {
            addCriterion("inventories >=", value, "inventories");
            return (Criteria) this;
        }

        public Criteria andInventoriesLessThan(Float value) {
            addCriterion("inventories <", value, "inventories");
            return (Criteria) this;
        }

        public Criteria andInventoriesLessThanOrEqualTo(Float value) {
            addCriterion("inventories <=", value, "inventories");
            return (Criteria) this;
        }

        public Criteria andInventoriesIn(List<Float> values) {
            addCriterion("inventories in", values, "inventories");
            return (Criteria) this;
        }

        public Criteria andInventoriesNotIn(List<Float> values) {
            addCriterion("inventories not in", values, "inventories");
            return (Criteria) this;
        }

        public Criteria andInventoriesBetween(Float value1, Float value2) {
            addCriterion("inventories between", value1, value2, "inventories");
            return (Criteria) this;
        }

        public Criteria andInventoriesNotBetween(Float value1, Float value2) {
            addCriterion("inventories not between", value1, value2, "inventories");
            return (Criteria) this;
        }

        public Criteria andAmorExpIsNull() {
            addCriterion("amor_exp is null");
            return (Criteria) this;
        }

        public Criteria andAmorExpIsNotNull() {
            addCriterion("amor_exp is not null");
            return (Criteria) this;
        }

        public Criteria andAmorExpEqualTo(Float value) {
            addCriterion("amor_exp =", value, "amorExp");
            return (Criteria) this;
        }

        public Criteria andAmorExpNotEqualTo(Float value) {
            addCriterion("amor_exp <>", value, "amorExp");
            return (Criteria) this;
        }

        public Criteria andAmorExpGreaterThan(Float value) {
            addCriterion("amor_exp >", value, "amorExp");
            return (Criteria) this;
        }

        public Criteria andAmorExpGreaterThanOrEqualTo(Float value) {
            addCriterion("amor_exp >=", value, "amorExp");
            return (Criteria) this;
        }

        public Criteria andAmorExpLessThan(Float value) {
            addCriterion("amor_exp <", value, "amorExp");
            return (Criteria) this;
        }

        public Criteria andAmorExpLessThanOrEqualTo(Float value) {
            addCriterion("amor_exp <=", value, "amorExp");
            return (Criteria) this;
        }

        public Criteria andAmorExpIn(List<Float> values) {
            addCriterion("amor_exp in", values, "amorExp");
            return (Criteria) this;
        }

        public Criteria andAmorExpNotIn(List<Float> values) {
            addCriterion("amor_exp not in", values, "amorExp");
            return (Criteria) this;
        }

        public Criteria andAmorExpBetween(Float value1, Float value2) {
            addCriterion("amor_exp between", value1, value2, "amorExp");
            return (Criteria) this;
        }

        public Criteria andAmorExpNotBetween(Float value1, Float value2) {
            addCriterion("amor_exp not between", value1, value2, "amorExp");
            return (Criteria) this;
        }

        public Criteria andNcaWithin1yIsNull() {
            addCriterion("nca_within_1y is null");
            return (Criteria) this;
        }

        public Criteria andNcaWithin1yIsNotNull() {
            addCriterion("nca_within_1y is not null");
            return (Criteria) this;
        }

        public Criteria andNcaWithin1yEqualTo(Float value) {
            addCriterion("nca_within_1y =", value, "ncaWithin1y");
            return (Criteria) this;
        }

        public Criteria andNcaWithin1yNotEqualTo(Float value) {
            addCriterion("nca_within_1y <>", value, "ncaWithin1y");
            return (Criteria) this;
        }

        public Criteria andNcaWithin1yGreaterThan(Float value) {
            addCriterion("nca_within_1y >", value, "ncaWithin1y");
            return (Criteria) this;
        }

        public Criteria andNcaWithin1yGreaterThanOrEqualTo(Float value) {
            addCriterion("nca_within_1y >=", value, "ncaWithin1y");
            return (Criteria) this;
        }

        public Criteria andNcaWithin1yLessThan(Float value) {
            addCriterion("nca_within_1y <", value, "ncaWithin1y");
            return (Criteria) this;
        }

        public Criteria andNcaWithin1yLessThanOrEqualTo(Float value) {
            addCriterion("nca_within_1y <=", value, "ncaWithin1y");
            return (Criteria) this;
        }

        public Criteria andNcaWithin1yIn(List<Float> values) {
            addCriterion("nca_within_1y in", values, "ncaWithin1y");
            return (Criteria) this;
        }

        public Criteria andNcaWithin1yNotIn(List<Float> values) {
            addCriterion("nca_within_1y not in", values, "ncaWithin1y");
            return (Criteria) this;
        }

        public Criteria andNcaWithin1yBetween(Float value1, Float value2) {
            addCriterion("nca_within_1y between", value1, value2, "ncaWithin1y");
            return (Criteria) this;
        }

        public Criteria andNcaWithin1yNotBetween(Float value1, Float value2) {
            addCriterion("nca_within_1y not between", value1, value2, "ncaWithin1y");
            return (Criteria) this;
        }

        public Criteria andSettRsrvIsNull() {
            addCriterion("sett_rsrv is null");
            return (Criteria) this;
        }

        public Criteria andSettRsrvIsNotNull() {
            addCriterion("sett_rsrv is not null");
            return (Criteria) this;
        }

        public Criteria andSettRsrvEqualTo(Float value) {
            addCriterion("sett_rsrv =", value, "settRsrv");
            return (Criteria) this;
        }

        public Criteria andSettRsrvNotEqualTo(Float value) {
            addCriterion("sett_rsrv <>", value, "settRsrv");
            return (Criteria) this;
        }

        public Criteria andSettRsrvGreaterThan(Float value) {
            addCriterion("sett_rsrv >", value, "settRsrv");
            return (Criteria) this;
        }

        public Criteria andSettRsrvGreaterThanOrEqualTo(Float value) {
            addCriterion("sett_rsrv >=", value, "settRsrv");
            return (Criteria) this;
        }

        public Criteria andSettRsrvLessThan(Float value) {
            addCriterion("sett_rsrv <", value, "settRsrv");
            return (Criteria) this;
        }

        public Criteria andSettRsrvLessThanOrEqualTo(Float value) {
            addCriterion("sett_rsrv <=", value, "settRsrv");
            return (Criteria) this;
        }

        public Criteria andSettRsrvIn(List<Float> values) {
            addCriterion("sett_rsrv in", values, "settRsrv");
            return (Criteria) this;
        }

        public Criteria andSettRsrvNotIn(List<Float> values) {
            addCriterion("sett_rsrv not in", values, "settRsrv");
            return (Criteria) this;
        }

        public Criteria andSettRsrvBetween(Float value1, Float value2) {
            addCriterion("sett_rsrv between", value1, value2, "settRsrv");
            return (Criteria) this;
        }

        public Criteria andSettRsrvNotBetween(Float value1, Float value2) {
            addCriterion("sett_rsrv not between", value1, value2, "settRsrv");
            return (Criteria) this;
        }

        public Criteria andLoantoOthBankFiIsNull() {
            addCriterion("loanto_oth_bank_fi is null");
            return (Criteria) this;
        }

        public Criteria andLoantoOthBankFiIsNotNull() {
            addCriterion("loanto_oth_bank_fi is not null");
            return (Criteria) this;
        }

        public Criteria andLoantoOthBankFiEqualTo(Float value) {
            addCriterion("loanto_oth_bank_fi =", value, "loantoOthBankFi");
            return (Criteria) this;
        }

        public Criteria andLoantoOthBankFiNotEqualTo(Float value) {
            addCriterion("loanto_oth_bank_fi <>", value, "loantoOthBankFi");
            return (Criteria) this;
        }

        public Criteria andLoantoOthBankFiGreaterThan(Float value) {
            addCriterion("loanto_oth_bank_fi >", value, "loantoOthBankFi");
            return (Criteria) this;
        }

        public Criteria andLoantoOthBankFiGreaterThanOrEqualTo(Float value) {
            addCriterion("loanto_oth_bank_fi >=", value, "loantoOthBankFi");
            return (Criteria) this;
        }

        public Criteria andLoantoOthBankFiLessThan(Float value) {
            addCriterion("loanto_oth_bank_fi <", value, "loantoOthBankFi");
            return (Criteria) this;
        }

        public Criteria andLoantoOthBankFiLessThanOrEqualTo(Float value) {
            addCriterion("loanto_oth_bank_fi <=", value, "loantoOthBankFi");
            return (Criteria) this;
        }

        public Criteria andLoantoOthBankFiIn(List<Float> values) {
            addCriterion("loanto_oth_bank_fi in", values, "loantoOthBankFi");
            return (Criteria) this;
        }

        public Criteria andLoantoOthBankFiNotIn(List<Float> values) {
            addCriterion("loanto_oth_bank_fi not in", values, "loantoOthBankFi");
            return (Criteria) this;
        }

        public Criteria andLoantoOthBankFiBetween(Float value1, Float value2) {
            addCriterion("loanto_oth_bank_fi between", value1, value2, "loantoOthBankFi");
            return (Criteria) this;
        }

        public Criteria andLoantoOthBankFiNotBetween(Float value1, Float value2) {
            addCriterion("loanto_oth_bank_fi not between", value1, value2, "loantoOthBankFi");
            return (Criteria) this;
        }

        public Criteria andPremiumReceivIsNull() {
            addCriterion("premium_receiv is null");
            return (Criteria) this;
        }

        public Criteria andPremiumReceivIsNotNull() {
            addCriterion("premium_receiv is not null");
            return (Criteria) this;
        }

        public Criteria andPremiumReceivEqualTo(Float value) {
            addCriterion("premium_receiv =", value, "premiumReceiv");
            return (Criteria) this;
        }

        public Criteria andPremiumReceivNotEqualTo(Float value) {
            addCriterion("premium_receiv <>", value, "premiumReceiv");
            return (Criteria) this;
        }

        public Criteria andPremiumReceivGreaterThan(Float value) {
            addCriterion("premium_receiv >", value, "premiumReceiv");
            return (Criteria) this;
        }

        public Criteria andPremiumReceivGreaterThanOrEqualTo(Float value) {
            addCriterion("premium_receiv >=", value, "premiumReceiv");
            return (Criteria) this;
        }

        public Criteria andPremiumReceivLessThan(Float value) {
            addCriterion("premium_receiv <", value, "premiumReceiv");
            return (Criteria) this;
        }

        public Criteria andPremiumReceivLessThanOrEqualTo(Float value) {
            addCriterion("premium_receiv <=", value, "premiumReceiv");
            return (Criteria) this;
        }

        public Criteria andPremiumReceivIn(List<Float> values) {
            addCriterion("premium_receiv in", values, "premiumReceiv");
            return (Criteria) this;
        }

        public Criteria andPremiumReceivNotIn(List<Float> values) {
            addCriterion("premium_receiv not in", values, "premiumReceiv");
            return (Criteria) this;
        }

        public Criteria andPremiumReceivBetween(Float value1, Float value2) {
            addCriterion("premium_receiv between", value1, value2, "premiumReceiv");
            return (Criteria) this;
        }

        public Criteria andPremiumReceivNotBetween(Float value1, Float value2) {
            addCriterion("premium_receiv not between", value1, value2, "premiumReceiv");
            return (Criteria) this;
        }

        public Criteria andReinsurReceivIsNull() {
            addCriterion("reinsur_receiv is null");
            return (Criteria) this;
        }

        public Criteria andReinsurReceivIsNotNull() {
            addCriterion("reinsur_receiv is not null");
            return (Criteria) this;
        }

        public Criteria andReinsurReceivEqualTo(Float value) {
            addCriterion("reinsur_receiv =", value, "reinsurReceiv");
            return (Criteria) this;
        }

        public Criteria andReinsurReceivNotEqualTo(Float value) {
            addCriterion("reinsur_receiv <>", value, "reinsurReceiv");
            return (Criteria) this;
        }

        public Criteria andReinsurReceivGreaterThan(Float value) {
            addCriterion("reinsur_receiv >", value, "reinsurReceiv");
            return (Criteria) this;
        }

        public Criteria andReinsurReceivGreaterThanOrEqualTo(Float value) {
            addCriterion("reinsur_receiv >=", value, "reinsurReceiv");
            return (Criteria) this;
        }

        public Criteria andReinsurReceivLessThan(Float value) {
            addCriterion("reinsur_receiv <", value, "reinsurReceiv");
            return (Criteria) this;
        }

        public Criteria andReinsurReceivLessThanOrEqualTo(Float value) {
            addCriterion("reinsur_receiv <=", value, "reinsurReceiv");
            return (Criteria) this;
        }

        public Criteria andReinsurReceivIn(List<Float> values) {
            addCriterion("reinsur_receiv in", values, "reinsurReceiv");
            return (Criteria) this;
        }

        public Criteria andReinsurReceivNotIn(List<Float> values) {
            addCriterion("reinsur_receiv not in", values, "reinsurReceiv");
            return (Criteria) this;
        }

        public Criteria andReinsurReceivBetween(Float value1, Float value2) {
            addCriterion("reinsur_receiv between", value1, value2, "reinsurReceiv");
            return (Criteria) this;
        }

        public Criteria andReinsurReceivNotBetween(Float value1, Float value2) {
            addCriterion("reinsur_receiv not between", value1, value2, "reinsurReceiv");
            return (Criteria) this;
        }

        public Criteria andReinsurResReceivIsNull() {
            addCriterion("reinsur_res_receiv is null");
            return (Criteria) this;
        }

        public Criteria andReinsurResReceivIsNotNull() {
            addCriterion("reinsur_res_receiv is not null");
            return (Criteria) this;
        }

        public Criteria andReinsurResReceivEqualTo(Float value) {
            addCriterion("reinsur_res_receiv =", value, "reinsurResReceiv");
            return (Criteria) this;
        }

        public Criteria andReinsurResReceivNotEqualTo(Float value) {
            addCriterion("reinsur_res_receiv <>", value, "reinsurResReceiv");
            return (Criteria) this;
        }

        public Criteria andReinsurResReceivGreaterThan(Float value) {
            addCriterion("reinsur_res_receiv >", value, "reinsurResReceiv");
            return (Criteria) this;
        }

        public Criteria andReinsurResReceivGreaterThanOrEqualTo(Float value) {
            addCriterion("reinsur_res_receiv >=", value, "reinsurResReceiv");
            return (Criteria) this;
        }

        public Criteria andReinsurResReceivLessThan(Float value) {
            addCriterion("reinsur_res_receiv <", value, "reinsurResReceiv");
            return (Criteria) this;
        }

        public Criteria andReinsurResReceivLessThanOrEqualTo(Float value) {
            addCriterion("reinsur_res_receiv <=", value, "reinsurResReceiv");
            return (Criteria) this;
        }

        public Criteria andReinsurResReceivIn(List<Float> values) {
            addCriterion("reinsur_res_receiv in", values, "reinsurResReceiv");
            return (Criteria) this;
        }

        public Criteria andReinsurResReceivNotIn(List<Float> values) {
            addCriterion("reinsur_res_receiv not in", values, "reinsurResReceiv");
            return (Criteria) this;
        }

        public Criteria andReinsurResReceivBetween(Float value1, Float value2) {
            addCriterion("reinsur_res_receiv between", value1, value2, "reinsurResReceiv");
            return (Criteria) this;
        }

        public Criteria andReinsurResReceivNotBetween(Float value1, Float value2) {
            addCriterion("reinsur_res_receiv not between", value1, value2, "reinsurResReceiv");
            return (Criteria) this;
        }

        public Criteria andPurResaleFaIsNull() {
            addCriterion("pur_resale_fa is null");
            return (Criteria) this;
        }

        public Criteria andPurResaleFaIsNotNull() {
            addCriterion("pur_resale_fa is not null");
            return (Criteria) this;
        }

        public Criteria andPurResaleFaEqualTo(Float value) {
            addCriterion("pur_resale_fa =", value, "purResaleFa");
            return (Criteria) this;
        }

        public Criteria andPurResaleFaNotEqualTo(Float value) {
            addCriterion("pur_resale_fa <>", value, "purResaleFa");
            return (Criteria) this;
        }

        public Criteria andPurResaleFaGreaterThan(Float value) {
            addCriterion("pur_resale_fa >", value, "purResaleFa");
            return (Criteria) this;
        }

        public Criteria andPurResaleFaGreaterThanOrEqualTo(Float value) {
            addCriterion("pur_resale_fa >=", value, "purResaleFa");
            return (Criteria) this;
        }

        public Criteria andPurResaleFaLessThan(Float value) {
            addCriterion("pur_resale_fa <", value, "purResaleFa");
            return (Criteria) this;
        }

        public Criteria andPurResaleFaLessThanOrEqualTo(Float value) {
            addCriterion("pur_resale_fa <=", value, "purResaleFa");
            return (Criteria) this;
        }

        public Criteria andPurResaleFaIn(List<Float> values) {
            addCriterion("pur_resale_fa in", values, "purResaleFa");
            return (Criteria) this;
        }

        public Criteria andPurResaleFaNotIn(List<Float> values) {
            addCriterion("pur_resale_fa not in", values, "purResaleFa");
            return (Criteria) this;
        }

        public Criteria andPurResaleFaBetween(Float value1, Float value2) {
            addCriterion("pur_resale_fa between", value1, value2, "purResaleFa");
            return (Criteria) this;
        }

        public Criteria andPurResaleFaNotBetween(Float value1, Float value2) {
            addCriterion("pur_resale_fa not between", value1, value2, "purResaleFa");
            return (Criteria) this;
        }

        public Criteria andOthCurAssetsIsNull() {
            addCriterion("oth_cur_assets is null");
            return (Criteria) this;
        }

        public Criteria andOthCurAssetsIsNotNull() {
            addCriterion("oth_cur_assets is not null");
            return (Criteria) this;
        }

        public Criteria andOthCurAssetsEqualTo(Float value) {
            addCriterion("oth_cur_assets =", value, "othCurAssets");
            return (Criteria) this;
        }

        public Criteria andOthCurAssetsNotEqualTo(Float value) {
            addCriterion("oth_cur_assets <>", value, "othCurAssets");
            return (Criteria) this;
        }

        public Criteria andOthCurAssetsGreaterThan(Float value) {
            addCriterion("oth_cur_assets >", value, "othCurAssets");
            return (Criteria) this;
        }

        public Criteria andOthCurAssetsGreaterThanOrEqualTo(Float value) {
            addCriterion("oth_cur_assets >=", value, "othCurAssets");
            return (Criteria) this;
        }

        public Criteria andOthCurAssetsLessThan(Float value) {
            addCriterion("oth_cur_assets <", value, "othCurAssets");
            return (Criteria) this;
        }

        public Criteria andOthCurAssetsLessThanOrEqualTo(Float value) {
            addCriterion("oth_cur_assets <=", value, "othCurAssets");
            return (Criteria) this;
        }

        public Criteria andOthCurAssetsIn(List<Float> values) {
            addCriterion("oth_cur_assets in", values, "othCurAssets");
            return (Criteria) this;
        }

        public Criteria andOthCurAssetsNotIn(List<Float> values) {
            addCriterion("oth_cur_assets not in", values, "othCurAssets");
            return (Criteria) this;
        }

        public Criteria andOthCurAssetsBetween(Float value1, Float value2) {
            addCriterion("oth_cur_assets between", value1, value2, "othCurAssets");
            return (Criteria) this;
        }

        public Criteria andOthCurAssetsNotBetween(Float value1, Float value2) {
            addCriterion("oth_cur_assets not between", value1, value2, "othCurAssets");
            return (Criteria) this;
        }

        public Criteria andTotalCurAssetsIsNull() {
            addCriterion("total_cur_assets is null");
            return (Criteria) this;
        }

        public Criteria andTotalCurAssetsIsNotNull() {
            addCriterion("total_cur_assets is not null");
            return (Criteria) this;
        }

        public Criteria andTotalCurAssetsEqualTo(Float value) {
            addCriterion("total_cur_assets =", value, "totalCurAssets");
            return (Criteria) this;
        }

        public Criteria andTotalCurAssetsNotEqualTo(Float value) {
            addCriterion("total_cur_assets <>", value, "totalCurAssets");
            return (Criteria) this;
        }

        public Criteria andTotalCurAssetsGreaterThan(Float value) {
            addCriterion("total_cur_assets >", value, "totalCurAssets");
            return (Criteria) this;
        }

        public Criteria andTotalCurAssetsGreaterThanOrEqualTo(Float value) {
            addCriterion("total_cur_assets >=", value, "totalCurAssets");
            return (Criteria) this;
        }

        public Criteria andTotalCurAssetsLessThan(Float value) {
            addCriterion("total_cur_assets <", value, "totalCurAssets");
            return (Criteria) this;
        }

        public Criteria andTotalCurAssetsLessThanOrEqualTo(Float value) {
            addCriterion("total_cur_assets <=", value, "totalCurAssets");
            return (Criteria) this;
        }

        public Criteria andTotalCurAssetsIn(List<Float> values) {
            addCriterion("total_cur_assets in", values, "totalCurAssets");
            return (Criteria) this;
        }

        public Criteria andTotalCurAssetsNotIn(List<Float> values) {
            addCriterion("total_cur_assets not in", values, "totalCurAssets");
            return (Criteria) this;
        }

        public Criteria andTotalCurAssetsBetween(Float value1, Float value2) {
            addCriterion("total_cur_assets between", value1, value2, "totalCurAssets");
            return (Criteria) this;
        }

        public Criteria andTotalCurAssetsNotBetween(Float value1, Float value2) {
            addCriterion("total_cur_assets not between", value1, value2, "totalCurAssets");
            return (Criteria) this;
        }

        public Criteria andFaAvailForSaleIsNull() {
            addCriterion("fa_avail_for_sale is null");
            return (Criteria) this;
        }

        public Criteria andFaAvailForSaleIsNotNull() {
            addCriterion("fa_avail_for_sale is not null");
            return (Criteria) this;
        }

        public Criteria andFaAvailForSaleEqualTo(Float value) {
            addCriterion("fa_avail_for_sale =", value, "faAvailForSale");
            return (Criteria) this;
        }

        public Criteria andFaAvailForSaleNotEqualTo(Float value) {
            addCriterion("fa_avail_for_sale <>", value, "faAvailForSale");
            return (Criteria) this;
        }

        public Criteria andFaAvailForSaleGreaterThan(Float value) {
            addCriterion("fa_avail_for_sale >", value, "faAvailForSale");
            return (Criteria) this;
        }

        public Criteria andFaAvailForSaleGreaterThanOrEqualTo(Float value) {
            addCriterion("fa_avail_for_sale >=", value, "faAvailForSale");
            return (Criteria) this;
        }

        public Criteria andFaAvailForSaleLessThan(Float value) {
            addCriterion("fa_avail_for_sale <", value, "faAvailForSale");
            return (Criteria) this;
        }

        public Criteria andFaAvailForSaleLessThanOrEqualTo(Float value) {
            addCriterion("fa_avail_for_sale <=", value, "faAvailForSale");
            return (Criteria) this;
        }

        public Criteria andFaAvailForSaleIn(List<Float> values) {
            addCriterion("fa_avail_for_sale in", values, "faAvailForSale");
            return (Criteria) this;
        }

        public Criteria andFaAvailForSaleNotIn(List<Float> values) {
            addCriterion("fa_avail_for_sale not in", values, "faAvailForSale");
            return (Criteria) this;
        }

        public Criteria andFaAvailForSaleBetween(Float value1, Float value2) {
            addCriterion("fa_avail_for_sale between", value1, value2, "faAvailForSale");
            return (Criteria) this;
        }

        public Criteria andFaAvailForSaleNotBetween(Float value1, Float value2) {
            addCriterion("fa_avail_for_sale not between", value1, value2, "faAvailForSale");
            return (Criteria) this;
        }

        public Criteria andHtmInvestIsNull() {
            addCriterion("htm_invest is null");
            return (Criteria) this;
        }

        public Criteria andHtmInvestIsNotNull() {
            addCriterion("htm_invest is not null");
            return (Criteria) this;
        }

        public Criteria andHtmInvestEqualTo(Float value) {
            addCriterion("htm_invest =", value, "htmInvest");
            return (Criteria) this;
        }

        public Criteria andHtmInvestNotEqualTo(Float value) {
            addCriterion("htm_invest <>", value, "htmInvest");
            return (Criteria) this;
        }

        public Criteria andHtmInvestGreaterThan(Float value) {
            addCriterion("htm_invest >", value, "htmInvest");
            return (Criteria) this;
        }

        public Criteria andHtmInvestGreaterThanOrEqualTo(Float value) {
            addCriterion("htm_invest >=", value, "htmInvest");
            return (Criteria) this;
        }

        public Criteria andHtmInvestLessThan(Float value) {
            addCriterion("htm_invest <", value, "htmInvest");
            return (Criteria) this;
        }

        public Criteria andHtmInvestLessThanOrEqualTo(Float value) {
            addCriterion("htm_invest <=", value, "htmInvest");
            return (Criteria) this;
        }

        public Criteria andHtmInvestIn(List<Float> values) {
            addCriterion("htm_invest in", values, "htmInvest");
            return (Criteria) this;
        }

        public Criteria andHtmInvestNotIn(List<Float> values) {
            addCriterion("htm_invest not in", values, "htmInvest");
            return (Criteria) this;
        }

        public Criteria andHtmInvestBetween(Float value1, Float value2) {
            addCriterion("htm_invest between", value1, value2, "htmInvest");
            return (Criteria) this;
        }

        public Criteria andHtmInvestNotBetween(Float value1, Float value2) {
            addCriterion("htm_invest not between", value1, value2, "htmInvest");
            return (Criteria) this;
        }

        public Criteria andLtEqtInvestIsNull() {
            addCriterion("lt_eqt_invest is null");
            return (Criteria) this;
        }

        public Criteria andLtEqtInvestIsNotNull() {
            addCriterion("lt_eqt_invest is not null");
            return (Criteria) this;
        }

        public Criteria andLtEqtInvestEqualTo(Float value) {
            addCriterion("lt_eqt_invest =", value, "ltEqtInvest");
            return (Criteria) this;
        }

        public Criteria andLtEqtInvestNotEqualTo(Float value) {
            addCriterion("lt_eqt_invest <>", value, "ltEqtInvest");
            return (Criteria) this;
        }

        public Criteria andLtEqtInvestGreaterThan(Float value) {
            addCriterion("lt_eqt_invest >", value, "ltEqtInvest");
            return (Criteria) this;
        }

        public Criteria andLtEqtInvestGreaterThanOrEqualTo(Float value) {
            addCriterion("lt_eqt_invest >=", value, "ltEqtInvest");
            return (Criteria) this;
        }

        public Criteria andLtEqtInvestLessThan(Float value) {
            addCriterion("lt_eqt_invest <", value, "ltEqtInvest");
            return (Criteria) this;
        }

        public Criteria andLtEqtInvestLessThanOrEqualTo(Float value) {
            addCriterion("lt_eqt_invest <=", value, "ltEqtInvest");
            return (Criteria) this;
        }

        public Criteria andLtEqtInvestIn(List<Float> values) {
            addCriterion("lt_eqt_invest in", values, "ltEqtInvest");
            return (Criteria) this;
        }

        public Criteria andLtEqtInvestNotIn(List<Float> values) {
            addCriterion("lt_eqt_invest not in", values, "ltEqtInvest");
            return (Criteria) this;
        }

        public Criteria andLtEqtInvestBetween(Float value1, Float value2) {
            addCriterion("lt_eqt_invest between", value1, value2, "ltEqtInvest");
            return (Criteria) this;
        }

        public Criteria andLtEqtInvestNotBetween(Float value1, Float value2) {
            addCriterion("lt_eqt_invest not between", value1, value2, "ltEqtInvest");
            return (Criteria) this;
        }

        public Criteria andInvestRealEstateIsNull() {
            addCriterion("invest_real_estate is null");
            return (Criteria) this;
        }

        public Criteria andInvestRealEstateIsNotNull() {
            addCriterion("invest_real_estate is not null");
            return (Criteria) this;
        }

        public Criteria andInvestRealEstateEqualTo(Float value) {
            addCriterion("invest_real_estate =", value, "investRealEstate");
            return (Criteria) this;
        }

        public Criteria andInvestRealEstateNotEqualTo(Float value) {
            addCriterion("invest_real_estate <>", value, "investRealEstate");
            return (Criteria) this;
        }

        public Criteria andInvestRealEstateGreaterThan(Float value) {
            addCriterion("invest_real_estate >", value, "investRealEstate");
            return (Criteria) this;
        }

        public Criteria andInvestRealEstateGreaterThanOrEqualTo(Float value) {
            addCriterion("invest_real_estate >=", value, "investRealEstate");
            return (Criteria) this;
        }

        public Criteria andInvestRealEstateLessThan(Float value) {
            addCriterion("invest_real_estate <", value, "investRealEstate");
            return (Criteria) this;
        }

        public Criteria andInvestRealEstateLessThanOrEqualTo(Float value) {
            addCriterion("invest_real_estate <=", value, "investRealEstate");
            return (Criteria) this;
        }

        public Criteria andInvestRealEstateIn(List<Float> values) {
            addCriterion("invest_real_estate in", values, "investRealEstate");
            return (Criteria) this;
        }

        public Criteria andInvestRealEstateNotIn(List<Float> values) {
            addCriterion("invest_real_estate not in", values, "investRealEstate");
            return (Criteria) this;
        }

        public Criteria andInvestRealEstateBetween(Float value1, Float value2) {
            addCriterion("invest_real_estate between", value1, value2, "investRealEstate");
            return (Criteria) this;
        }

        public Criteria andInvestRealEstateNotBetween(Float value1, Float value2) {
            addCriterion("invest_real_estate not between", value1, value2, "investRealEstate");
            return (Criteria) this;
        }

        public Criteria andTimeDepositsIsNull() {
            addCriterion("time_deposits is null");
            return (Criteria) this;
        }

        public Criteria andTimeDepositsIsNotNull() {
            addCriterion("time_deposits is not null");
            return (Criteria) this;
        }

        public Criteria andTimeDepositsEqualTo(Float value) {
            addCriterion("time_deposits =", value, "timeDeposits");
            return (Criteria) this;
        }

        public Criteria andTimeDepositsNotEqualTo(Float value) {
            addCriterion("time_deposits <>", value, "timeDeposits");
            return (Criteria) this;
        }

        public Criteria andTimeDepositsGreaterThan(Float value) {
            addCriterion("time_deposits >", value, "timeDeposits");
            return (Criteria) this;
        }

        public Criteria andTimeDepositsGreaterThanOrEqualTo(Float value) {
            addCriterion("time_deposits >=", value, "timeDeposits");
            return (Criteria) this;
        }

        public Criteria andTimeDepositsLessThan(Float value) {
            addCriterion("time_deposits <", value, "timeDeposits");
            return (Criteria) this;
        }

        public Criteria andTimeDepositsLessThanOrEqualTo(Float value) {
            addCriterion("time_deposits <=", value, "timeDeposits");
            return (Criteria) this;
        }

        public Criteria andTimeDepositsIn(List<Float> values) {
            addCriterion("time_deposits in", values, "timeDeposits");
            return (Criteria) this;
        }

        public Criteria andTimeDepositsNotIn(List<Float> values) {
            addCriterion("time_deposits not in", values, "timeDeposits");
            return (Criteria) this;
        }

        public Criteria andTimeDepositsBetween(Float value1, Float value2) {
            addCriterion("time_deposits between", value1, value2, "timeDeposits");
            return (Criteria) this;
        }

        public Criteria andTimeDepositsNotBetween(Float value1, Float value2) {
            addCriterion("time_deposits not between", value1, value2, "timeDeposits");
            return (Criteria) this;
        }

        public Criteria andOthAssetsIsNull() {
            addCriterion("oth_assets is null");
            return (Criteria) this;
        }

        public Criteria andOthAssetsIsNotNull() {
            addCriterion("oth_assets is not null");
            return (Criteria) this;
        }

        public Criteria andOthAssetsEqualTo(Float value) {
            addCriterion("oth_assets =", value, "othAssets");
            return (Criteria) this;
        }

        public Criteria andOthAssetsNotEqualTo(Float value) {
            addCriterion("oth_assets <>", value, "othAssets");
            return (Criteria) this;
        }

        public Criteria andOthAssetsGreaterThan(Float value) {
            addCriterion("oth_assets >", value, "othAssets");
            return (Criteria) this;
        }

        public Criteria andOthAssetsGreaterThanOrEqualTo(Float value) {
            addCriterion("oth_assets >=", value, "othAssets");
            return (Criteria) this;
        }

        public Criteria andOthAssetsLessThan(Float value) {
            addCriterion("oth_assets <", value, "othAssets");
            return (Criteria) this;
        }

        public Criteria andOthAssetsLessThanOrEqualTo(Float value) {
            addCriterion("oth_assets <=", value, "othAssets");
            return (Criteria) this;
        }

        public Criteria andOthAssetsIn(List<Float> values) {
            addCriterion("oth_assets in", values, "othAssets");
            return (Criteria) this;
        }

        public Criteria andOthAssetsNotIn(List<Float> values) {
            addCriterion("oth_assets not in", values, "othAssets");
            return (Criteria) this;
        }

        public Criteria andOthAssetsBetween(Float value1, Float value2) {
            addCriterion("oth_assets between", value1, value2, "othAssets");
            return (Criteria) this;
        }

        public Criteria andOthAssetsNotBetween(Float value1, Float value2) {
            addCriterion("oth_assets not between", value1, value2, "othAssets");
            return (Criteria) this;
        }

        public Criteria andLtRecIsNull() {
            addCriterion("lt_rec is null");
            return (Criteria) this;
        }

        public Criteria andLtRecIsNotNull() {
            addCriterion("lt_rec is not null");
            return (Criteria) this;
        }

        public Criteria andLtRecEqualTo(Float value) {
            addCriterion("lt_rec =", value, "ltRec");
            return (Criteria) this;
        }

        public Criteria andLtRecNotEqualTo(Float value) {
            addCriterion("lt_rec <>", value, "ltRec");
            return (Criteria) this;
        }

        public Criteria andLtRecGreaterThan(Float value) {
            addCriterion("lt_rec >", value, "ltRec");
            return (Criteria) this;
        }

        public Criteria andLtRecGreaterThanOrEqualTo(Float value) {
            addCriterion("lt_rec >=", value, "ltRec");
            return (Criteria) this;
        }

        public Criteria andLtRecLessThan(Float value) {
            addCriterion("lt_rec <", value, "ltRec");
            return (Criteria) this;
        }

        public Criteria andLtRecLessThanOrEqualTo(Float value) {
            addCriterion("lt_rec <=", value, "ltRec");
            return (Criteria) this;
        }

        public Criteria andLtRecIn(List<Float> values) {
            addCriterion("lt_rec in", values, "ltRec");
            return (Criteria) this;
        }

        public Criteria andLtRecNotIn(List<Float> values) {
            addCriterion("lt_rec not in", values, "ltRec");
            return (Criteria) this;
        }

        public Criteria andLtRecBetween(Float value1, Float value2) {
            addCriterion("lt_rec between", value1, value2, "ltRec");
            return (Criteria) this;
        }

        public Criteria andLtRecNotBetween(Float value1, Float value2) {
            addCriterion("lt_rec not between", value1, value2, "ltRec");
            return (Criteria) this;
        }

        public Criteria andFixAssetsIsNull() {
            addCriterion("fix_assets is null");
            return (Criteria) this;
        }

        public Criteria andFixAssetsIsNotNull() {
            addCriterion("fix_assets is not null");
            return (Criteria) this;
        }

        public Criteria andFixAssetsEqualTo(Float value) {
            addCriterion("fix_assets =", value, "fixAssets");
            return (Criteria) this;
        }

        public Criteria andFixAssetsNotEqualTo(Float value) {
            addCriterion("fix_assets <>", value, "fixAssets");
            return (Criteria) this;
        }

        public Criteria andFixAssetsGreaterThan(Float value) {
            addCriterion("fix_assets >", value, "fixAssets");
            return (Criteria) this;
        }

        public Criteria andFixAssetsGreaterThanOrEqualTo(Float value) {
            addCriterion("fix_assets >=", value, "fixAssets");
            return (Criteria) this;
        }

        public Criteria andFixAssetsLessThan(Float value) {
            addCriterion("fix_assets <", value, "fixAssets");
            return (Criteria) this;
        }

        public Criteria andFixAssetsLessThanOrEqualTo(Float value) {
            addCriterion("fix_assets <=", value, "fixAssets");
            return (Criteria) this;
        }

        public Criteria andFixAssetsIn(List<Float> values) {
            addCriterion("fix_assets in", values, "fixAssets");
            return (Criteria) this;
        }

        public Criteria andFixAssetsNotIn(List<Float> values) {
            addCriterion("fix_assets not in", values, "fixAssets");
            return (Criteria) this;
        }

        public Criteria andFixAssetsBetween(Float value1, Float value2) {
            addCriterion("fix_assets between", value1, value2, "fixAssets");
            return (Criteria) this;
        }

        public Criteria andFixAssetsNotBetween(Float value1, Float value2) {
            addCriterion("fix_assets not between", value1, value2, "fixAssets");
            return (Criteria) this;
        }

        public Criteria andCipIsNull() {
            addCriterion("cip is null");
            return (Criteria) this;
        }

        public Criteria andCipIsNotNull() {
            addCriterion("cip is not null");
            return (Criteria) this;
        }

        public Criteria andCipEqualTo(Float value) {
            addCriterion("cip =", value, "cip");
            return (Criteria) this;
        }

        public Criteria andCipNotEqualTo(Float value) {
            addCriterion("cip <>", value, "cip");
            return (Criteria) this;
        }

        public Criteria andCipGreaterThan(Float value) {
            addCriterion("cip >", value, "cip");
            return (Criteria) this;
        }

        public Criteria andCipGreaterThanOrEqualTo(Float value) {
            addCriterion("cip >=", value, "cip");
            return (Criteria) this;
        }

        public Criteria andCipLessThan(Float value) {
            addCriterion("cip <", value, "cip");
            return (Criteria) this;
        }

        public Criteria andCipLessThanOrEqualTo(Float value) {
            addCriterion("cip <=", value, "cip");
            return (Criteria) this;
        }

        public Criteria andCipIn(List<Float> values) {
            addCriterion("cip in", values, "cip");
            return (Criteria) this;
        }

        public Criteria andCipNotIn(List<Float> values) {
            addCriterion("cip not in", values, "cip");
            return (Criteria) this;
        }

        public Criteria andCipBetween(Float value1, Float value2) {
            addCriterion("cip between", value1, value2, "cip");
            return (Criteria) this;
        }

        public Criteria andCipNotBetween(Float value1, Float value2) {
            addCriterion("cip not between", value1, value2, "cip");
            return (Criteria) this;
        }

        public Criteria andConstMaterialsIsNull() {
            addCriterion("const_materials is null");
            return (Criteria) this;
        }

        public Criteria andConstMaterialsIsNotNull() {
            addCriterion("const_materials is not null");
            return (Criteria) this;
        }

        public Criteria andConstMaterialsEqualTo(Float value) {
            addCriterion("const_materials =", value, "constMaterials");
            return (Criteria) this;
        }

        public Criteria andConstMaterialsNotEqualTo(Float value) {
            addCriterion("const_materials <>", value, "constMaterials");
            return (Criteria) this;
        }

        public Criteria andConstMaterialsGreaterThan(Float value) {
            addCriterion("const_materials >", value, "constMaterials");
            return (Criteria) this;
        }

        public Criteria andConstMaterialsGreaterThanOrEqualTo(Float value) {
            addCriterion("const_materials >=", value, "constMaterials");
            return (Criteria) this;
        }

        public Criteria andConstMaterialsLessThan(Float value) {
            addCriterion("const_materials <", value, "constMaterials");
            return (Criteria) this;
        }

        public Criteria andConstMaterialsLessThanOrEqualTo(Float value) {
            addCriterion("const_materials <=", value, "constMaterials");
            return (Criteria) this;
        }

        public Criteria andConstMaterialsIn(List<Float> values) {
            addCriterion("const_materials in", values, "constMaterials");
            return (Criteria) this;
        }

        public Criteria andConstMaterialsNotIn(List<Float> values) {
            addCriterion("const_materials not in", values, "constMaterials");
            return (Criteria) this;
        }

        public Criteria andConstMaterialsBetween(Float value1, Float value2) {
            addCriterion("const_materials between", value1, value2, "constMaterials");
            return (Criteria) this;
        }

        public Criteria andConstMaterialsNotBetween(Float value1, Float value2) {
            addCriterion("const_materials not between", value1, value2, "constMaterials");
            return (Criteria) this;
        }

        public Criteria andFixedAssetsDispIsNull() {
            addCriterion("fixed_assets_disp is null");
            return (Criteria) this;
        }

        public Criteria andFixedAssetsDispIsNotNull() {
            addCriterion("fixed_assets_disp is not null");
            return (Criteria) this;
        }

        public Criteria andFixedAssetsDispEqualTo(Float value) {
            addCriterion("fixed_assets_disp =", value, "fixedAssetsDisp");
            return (Criteria) this;
        }

        public Criteria andFixedAssetsDispNotEqualTo(Float value) {
            addCriterion("fixed_assets_disp <>", value, "fixedAssetsDisp");
            return (Criteria) this;
        }

        public Criteria andFixedAssetsDispGreaterThan(Float value) {
            addCriterion("fixed_assets_disp >", value, "fixedAssetsDisp");
            return (Criteria) this;
        }

        public Criteria andFixedAssetsDispGreaterThanOrEqualTo(Float value) {
            addCriterion("fixed_assets_disp >=", value, "fixedAssetsDisp");
            return (Criteria) this;
        }

        public Criteria andFixedAssetsDispLessThan(Float value) {
            addCriterion("fixed_assets_disp <", value, "fixedAssetsDisp");
            return (Criteria) this;
        }

        public Criteria andFixedAssetsDispLessThanOrEqualTo(Float value) {
            addCriterion("fixed_assets_disp <=", value, "fixedAssetsDisp");
            return (Criteria) this;
        }

        public Criteria andFixedAssetsDispIn(List<Float> values) {
            addCriterion("fixed_assets_disp in", values, "fixedAssetsDisp");
            return (Criteria) this;
        }

        public Criteria andFixedAssetsDispNotIn(List<Float> values) {
            addCriterion("fixed_assets_disp not in", values, "fixedAssetsDisp");
            return (Criteria) this;
        }

        public Criteria andFixedAssetsDispBetween(Float value1, Float value2) {
            addCriterion("fixed_assets_disp between", value1, value2, "fixedAssetsDisp");
            return (Criteria) this;
        }

        public Criteria andFixedAssetsDispNotBetween(Float value1, Float value2) {
            addCriterion("fixed_assets_disp not between", value1, value2, "fixedAssetsDisp");
            return (Criteria) this;
        }

        public Criteria andProducBioAssetsIsNull() {
            addCriterion("produc_bio_assets is null");
            return (Criteria) this;
        }

        public Criteria andProducBioAssetsIsNotNull() {
            addCriterion("produc_bio_assets is not null");
            return (Criteria) this;
        }

        public Criteria andProducBioAssetsEqualTo(Float value) {
            addCriterion("produc_bio_assets =", value, "producBioAssets");
            return (Criteria) this;
        }

        public Criteria andProducBioAssetsNotEqualTo(Float value) {
            addCriterion("produc_bio_assets <>", value, "producBioAssets");
            return (Criteria) this;
        }

        public Criteria andProducBioAssetsGreaterThan(Float value) {
            addCriterion("produc_bio_assets >", value, "producBioAssets");
            return (Criteria) this;
        }

        public Criteria andProducBioAssetsGreaterThanOrEqualTo(Float value) {
            addCriterion("produc_bio_assets >=", value, "producBioAssets");
            return (Criteria) this;
        }

        public Criteria andProducBioAssetsLessThan(Float value) {
            addCriterion("produc_bio_assets <", value, "producBioAssets");
            return (Criteria) this;
        }

        public Criteria andProducBioAssetsLessThanOrEqualTo(Float value) {
            addCriterion("produc_bio_assets <=", value, "producBioAssets");
            return (Criteria) this;
        }

        public Criteria andProducBioAssetsIn(List<Float> values) {
            addCriterion("produc_bio_assets in", values, "producBioAssets");
            return (Criteria) this;
        }

        public Criteria andProducBioAssetsNotIn(List<Float> values) {
            addCriterion("produc_bio_assets not in", values, "producBioAssets");
            return (Criteria) this;
        }

        public Criteria andProducBioAssetsBetween(Float value1, Float value2) {
            addCriterion("produc_bio_assets between", value1, value2, "producBioAssets");
            return (Criteria) this;
        }

        public Criteria andProducBioAssetsNotBetween(Float value1, Float value2) {
            addCriterion("produc_bio_assets not between", value1, value2, "producBioAssets");
            return (Criteria) this;
        }

        public Criteria andOilAndGasAssetsIsNull() {
            addCriterion("oil_and_gas_assets is null");
            return (Criteria) this;
        }

        public Criteria andOilAndGasAssetsIsNotNull() {
            addCriterion("oil_and_gas_assets is not null");
            return (Criteria) this;
        }

        public Criteria andOilAndGasAssetsEqualTo(Float value) {
            addCriterion("oil_and_gas_assets =", value, "oilAndGasAssets");
            return (Criteria) this;
        }

        public Criteria andOilAndGasAssetsNotEqualTo(Float value) {
            addCriterion("oil_and_gas_assets <>", value, "oilAndGasAssets");
            return (Criteria) this;
        }

        public Criteria andOilAndGasAssetsGreaterThan(Float value) {
            addCriterion("oil_and_gas_assets >", value, "oilAndGasAssets");
            return (Criteria) this;
        }

        public Criteria andOilAndGasAssetsGreaterThanOrEqualTo(Float value) {
            addCriterion("oil_and_gas_assets >=", value, "oilAndGasAssets");
            return (Criteria) this;
        }

        public Criteria andOilAndGasAssetsLessThan(Float value) {
            addCriterion("oil_and_gas_assets <", value, "oilAndGasAssets");
            return (Criteria) this;
        }

        public Criteria andOilAndGasAssetsLessThanOrEqualTo(Float value) {
            addCriterion("oil_and_gas_assets <=", value, "oilAndGasAssets");
            return (Criteria) this;
        }

        public Criteria andOilAndGasAssetsIn(List<Float> values) {
            addCriterion("oil_and_gas_assets in", values, "oilAndGasAssets");
            return (Criteria) this;
        }

        public Criteria andOilAndGasAssetsNotIn(List<Float> values) {
            addCriterion("oil_and_gas_assets not in", values, "oilAndGasAssets");
            return (Criteria) this;
        }

        public Criteria andOilAndGasAssetsBetween(Float value1, Float value2) {
            addCriterion("oil_and_gas_assets between", value1, value2, "oilAndGasAssets");
            return (Criteria) this;
        }

        public Criteria andOilAndGasAssetsNotBetween(Float value1, Float value2) {
            addCriterion("oil_and_gas_assets not between", value1, value2, "oilAndGasAssets");
            return (Criteria) this;
        }

        public Criteria andIntanAssetsIsNull() {
            addCriterion("intan_assets is null");
            return (Criteria) this;
        }

        public Criteria andIntanAssetsIsNotNull() {
            addCriterion("intan_assets is not null");
            return (Criteria) this;
        }

        public Criteria andIntanAssetsEqualTo(Float value) {
            addCriterion("intan_assets =", value, "intanAssets");
            return (Criteria) this;
        }

        public Criteria andIntanAssetsNotEqualTo(Float value) {
            addCriterion("intan_assets <>", value, "intanAssets");
            return (Criteria) this;
        }

        public Criteria andIntanAssetsGreaterThan(Float value) {
            addCriterion("intan_assets >", value, "intanAssets");
            return (Criteria) this;
        }

        public Criteria andIntanAssetsGreaterThanOrEqualTo(Float value) {
            addCriterion("intan_assets >=", value, "intanAssets");
            return (Criteria) this;
        }

        public Criteria andIntanAssetsLessThan(Float value) {
            addCriterion("intan_assets <", value, "intanAssets");
            return (Criteria) this;
        }

        public Criteria andIntanAssetsLessThanOrEqualTo(Float value) {
            addCriterion("intan_assets <=", value, "intanAssets");
            return (Criteria) this;
        }

        public Criteria andIntanAssetsIn(List<Float> values) {
            addCriterion("intan_assets in", values, "intanAssets");
            return (Criteria) this;
        }

        public Criteria andIntanAssetsNotIn(List<Float> values) {
            addCriterion("intan_assets not in", values, "intanAssets");
            return (Criteria) this;
        }

        public Criteria andIntanAssetsBetween(Float value1, Float value2) {
            addCriterion("intan_assets between", value1, value2, "intanAssets");
            return (Criteria) this;
        }

        public Criteria andIntanAssetsNotBetween(Float value1, Float value2) {
            addCriterion("intan_assets not between", value1, value2, "intanAssets");
            return (Criteria) this;
        }

        public Criteria andRAndDIsNull() {
            addCriterion("r_and_d is null");
            return (Criteria) this;
        }

        public Criteria andRAndDIsNotNull() {
            addCriterion("r_and_d is not null");
            return (Criteria) this;
        }

        public Criteria andRAndDEqualTo(Float value) {
            addCriterion("r_and_d =", value, "rAndD");
            return (Criteria) this;
        }

        public Criteria andRAndDNotEqualTo(Float value) {
            addCriterion("r_and_d <>", value, "rAndD");
            return (Criteria) this;
        }

        public Criteria andRAndDGreaterThan(Float value) {
            addCriterion("r_and_d >", value, "rAndD");
            return (Criteria) this;
        }

        public Criteria andRAndDGreaterThanOrEqualTo(Float value) {
            addCriterion("r_and_d >=", value, "rAndD");
            return (Criteria) this;
        }

        public Criteria andRAndDLessThan(Float value) {
            addCriterion("r_and_d <", value, "rAndD");
            return (Criteria) this;
        }

        public Criteria andRAndDLessThanOrEqualTo(Float value) {
            addCriterion("r_and_d <=", value, "rAndD");
            return (Criteria) this;
        }

        public Criteria andRAndDIn(List<Float> values) {
            addCriterion("r_and_d in", values, "rAndD");
            return (Criteria) this;
        }

        public Criteria andRAndDNotIn(List<Float> values) {
            addCriterion("r_and_d not in", values, "rAndD");
            return (Criteria) this;
        }

        public Criteria andRAndDBetween(Float value1, Float value2) {
            addCriterion("r_and_d between", value1, value2, "rAndD");
            return (Criteria) this;
        }

        public Criteria andRAndDNotBetween(Float value1, Float value2) {
            addCriterion("r_and_d not between", value1, value2, "rAndD");
            return (Criteria) this;
        }

        public Criteria andGoodwillIsNull() {
            addCriterion("goodwill is null");
            return (Criteria) this;
        }

        public Criteria andGoodwillIsNotNull() {
            addCriterion("goodwill is not null");
            return (Criteria) this;
        }

        public Criteria andGoodwillEqualTo(Float value) {
            addCriterion("goodwill =", value, "goodwill");
            return (Criteria) this;
        }

        public Criteria andGoodwillNotEqualTo(Float value) {
            addCriterion("goodwill <>", value, "goodwill");
            return (Criteria) this;
        }

        public Criteria andGoodwillGreaterThan(Float value) {
            addCriterion("goodwill >", value, "goodwill");
            return (Criteria) this;
        }

        public Criteria andGoodwillGreaterThanOrEqualTo(Float value) {
            addCriterion("goodwill >=", value, "goodwill");
            return (Criteria) this;
        }

        public Criteria andGoodwillLessThan(Float value) {
            addCriterion("goodwill <", value, "goodwill");
            return (Criteria) this;
        }

        public Criteria andGoodwillLessThanOrEqualTo(Float value) {
            addCriterion("goodwill <=", value, "goodwill");
            return (Criteria) this;
        }

        public Criteria andGoodwillIn(List<Float> values) {
            addCriterion("goodwill in", values, "goodwill");
            return (Criteria) this;
        }

        public Criteria andGoodwillNotIn(List<Float> values) {
            addCriterion("goodwill not in", values, "goodwill");
            return (Criteria) this;
        }

        public Criteria andGoodwillBetween(Float value1, Float value2) {
            addCriterion("goodwill between", value1, value2, "goodwill");
            return (Criteria) this;
        }

        public Criteria andGoodwillNotBetween(Float value1, Float value2) {
            addCriterion("goodwill not between", value1, value2, "goodwill");
            return (Criteria) this;
        }

        public Criteria andLtAmorExpIsNull() {
            addCriterion("lt_amor_exp is null");
            return (Criteria) this;
        }

        public Criteria andLtAmorExpIsNotNull() {
            addCriterion("lt_amor_exp is not null");
            return (Criteria) this;
        }

        public Criteria andLtAmorExpEqualTo(Float value) {
            addCriterion("lt_amor_exp =", value, "ltAmorExp");
            return (Criteria) this;
        }

        public Criteria andLtAmorExpNotEqualTo(Float value) {
            addCriterion("lt_amor_exp <>", value, "ltAmorExp");
            return (Criteria) this;
        }

        public Criteria andLtAmorExpGreaterThan(Float value) {
            addCriterion("lt_amor_exp >", value, "ltAmorExp");
            return (Criteria) this;
        }

        public Criteria andLtAmorExpGreaterThanOrEqualTo(Float value) {
            addCriterion("lt_amor_exp >=", value, "ltAmorExp");
            return (Criteria) this;
        }

        public Criteria andLtAmorExpLessThan(Float value) {
            addCriterion("lt_amor_exp <", value, "ltAmorExp");
            return (Criteria) this;
        }

        public Criteria andLtAmorExpLessThanOrEqualTo(Float value) {
            addCriterion("lt_amor_exp <=", value, "ltAmorExp");
            return (Criteria) this;
        }

        public Criteria andLtAmorExpIn(List<Float> values) {
            addCriterion("lt_amor_exp in", values, "ltAmorExp");
            return (Criteria) this;
        }

        public Criteria andLtAmorExpNotIn(List<Float> values) {
            addCriterion("lt_amor_exp not in", values, "ltAmorExp");
            return (Criteria) this;
        }

        public Criteria andLtAmorExpBetween(Float value1, Float value2) {
            addCriterion("lt_amor_exp between", value1, value2, "ltAmorExp");
            return (Criteria) this;
        }

        public Criteria andLtAmorExpNotBetween(Float value1, Float value2) {
            addCriterion("lt_amor_exp not between", value1, value2, "ltAmorExp");
            return (Criteria) this;
        }

        public Criteria andDeferTaxAssetsIsNull() {
            addCriterion("defer_tax_assets is null");
            return (Criteria) this;
        }

        public Criteria andDeferTaxAssetsIsNotNull() {
            addCriterion("defer_tax_assets is not null");
            return (Criteria) this;
        }

        public Criteria andDeferTaxAssetsEqualTo(Float value) {
            addCriterion("defer_tax_assets =", value, "deferTaxAssets");
            return (Criteria) this;
        }

        public Criteria andDeferTaxAssetsNotEqualTo(Float value) {
            addCriterion("defer_tax_assets <>", value, "deferTaxAssets");
            return (Criteria) this;
        }

        public Criteria andDeferTaxAssetsGreaterThan(Float value) {
            addCriterion("defer_tax_assets >", value, "deferTaxAssets");
            return (Criteria) this;
        }

        public Criteria andDeferTaxAssetsGreaterThanOrEqualTo(Float value) {
            addCriterion("defer_tax_assets >=", value, "deferTaxAssets");
            return (Criteria) this;
        }

        public Criteria andDeferTaxAssetsLessThan(Float value) {
            addCriterion("defer_tax_assets <", value, "deferTaxAssets");
            return (Criteria) this;
        }

        public Criteria andDeferTaxAssetsLessThanOrEqualTo(Float value) {
            addCriterion("defer_tax_assets <=", value, "deferTaxAssets");
            return (Criteria) this;
        }

        public Criteria andDeferTaxAssetsIn(List<Float> values) {
            addCriterion("defer_tax_assets in", values, "deferTaxAssets");
            return (Criteria) this;
        }

        public Criteria andDeferTaxAssetsNotIn(List<Float> values) {
            addCriterion("defer_tax_assets not in", values, "deferTaxAssets");
            return (Criteria) this;
        }

        public Criteria andDeferTaxAssetsBetween(Float value1, Float value2) {
            addCriterion("defer_tax_assets between", value1, value2, "deferTaxAssets");
            return (Criteria) this;
        }

        public Criteria andDeferTaxAssetsNotBetween(Float value1, Float value2) {
            addCriterion("defer_tax_assets not between", value1, value2, "deferTaxAssets");
            return (Criteria) this;
        }

        public Criteria andDecrInDisburIsNull() {
            addCriterion("decr_in_disbur is null");
            return (Criteria) this;
        }

        public Criteria andDecrInDisburIsNotNull() {
            addCriterion("decr_in_disbur is not null");
            return (Criteria) this;
        }

        public Criteria andDecrInDisburEqualTo(Float value) {
            addCriterion("decr_in_disbur =", value, "decrInDisbur");
            return (Criteria) this;
        }

        public Criteria andDecrInDisburNotEqualTo(Float value) {
            addCriterion("decr_in_disbur <>", value, "decrInDisbur");
            return (Criteria) this;
        }

        public Criteria andDecrInDisburGreaterThan(Float value) {
            addCriterion("decr_in_disbur >", value, "decrInDisbur");
            return (Criteria) this;
        }

        public Criteria andDecrInDisburGreaterThanOrEqualTo(Float value) {
            addCriterion("decr_in_disbur >=", value, "decrInDisbur");
            return (Criteria) this;
        }

        public Criteria andDecrInDisburLessThan(Float value) {
            addCriterion("decr_in_disbur <", value, "decrInDisbur");
            return (Criteria) this;
        }

        public Criteria andDecrInDisburLessThanOrEqualTo(Float value) {
            addCriterion("decr_in_disbur <=", value, "decrInDisbur");
            return (Criteria) this;
        }

        public Criteria andDecrInDisburIn(List<Float> values) {
            addCriterion("decr_in_disbur in", values, "decrInDisbur");
            return (Criteria) this;
        }

        public Criteria andDecrInDisburNotIn(List<Float> values) {
            addCriterion("decr_in_disbur not in", values, "decrInDisbur");
            return (Criteria) this;
        }

        public Criteria andDecrInDisburBetween(Float value1, Float value2) {
            addCriterion("decr_in_disbur between", value1, value2, "decrInDisbur");
            return (Criteria) this;
        }

        public Criteria andDecrInDisburNotBetween(Float value1, Float value2) {
            addCriterion("decr_in_disbur not between", value1, value2, "decrInDisbur");
            return (Criteria) this;
        }

        public Criteria andOthNcaIsNull() {
            addCriterion("oth_nca is null");
            return (Criteria) this;
        }

        public Criteria andOthNcaIsNotNull() {
            addCriterion("oth_nca is not null");
            return (Criteria) this;
        }

        public Criteria andOthNcaEqualTo(Float value) {
            addCriterion("oth_nca =", value, "othNca");
            return (Criteria) this;
        }

        public Criteria andOthNcaNotEqualTo(Float value) {
            addCriterion("oth_nca <>", value, "othNca");
            return (Criteria) this;
        }

        public Criteria andOthNcaGreaterThan(Float value) {
            addCriterion("oth_nca >", value, "othNca");
            return (Criteria) this;
        }

        public Criteria andOthNcaGreaterThanOrEqualTo(Float value) {
            addCriterion("oth_nca >=", value, "othNca");
            return (Criteria) this;
        }

        public Criteria andOthNcaLessThan(Float value) {
            addCriterion("oth_nca <", value, "othNca");
            return (Criteria) this;
        }

        public Criteria andOthNcaLessThanOrEqualTo(Float value) {
            addCriterion("oth_nca <=", value, "othNca");
            return (Criteria) this;
        }

        public Criteria andOthNcaIn(List<Float> values) {
            addCriterion("oth_nca in", values, "othNca");
            return (Criteria) this;
        }

        public Criteria andOthNcaNotIn(List<Float> values) {
            addCriterion("oth_nca not in", values, "othNca");
            return (Criteria) this;
        }

        public Criteria andOthNcaBetween(Float value1, Float value2) {
            addCriterion("oth_nca between", value1, value2, "othNca");
            return (Criteria) this;
        }

        public Criteria andOthNcaNotBetween(Float value1, Float value2) {
            addCriterion("oth_nca not between", value1, value2, "othNca");
            return (Criteria) this;
        }

        public Criteria andTotalNcaIsNull() {
            addCriterion("total_nca is null");
            return (Criteria) this;
        }

        public Criteria andTotalNcaIsNotNull() {
            addCriterion("total_nca is not null");
            return (Criteria) this;
        }

        public Criteria andTotalNcaEqualTo(Float value) {
            addCriterion("total_nca =", value, "totalNca");
            return (Criteria) this;
        }

        public Criteria andTotalNcaNotEqualTo(Float value) {
            addCriterion("total_nca <>", value, "totalNca");
            return (Criteria) this;
        }

        public Criteria andTotalNcaGreaterThan(Float value) {
            addCriterion("total_nca >", value, "totalNca");
            return (Criteria) this;
        }

        public Criteria andTotalNcaGreaterThanOrEqualTo(Float value) {
            addCriterion("total_nca >=", value, "totalNca");
            return (Criteria) this;
        }

        public Criteria andTotalNcaLessThan(Float value) {
            addCriterion("total_nca <", value, "totalNca");
            return (Criteria) this;
        }

        public Criteria andTotalNcaLessThanOrEqualTo(Float value) {
            addCriterion("total_nca <=", value, "totalNca");
            return (Criteria) this;
        }

        public Criteria andTotalNcaIn(List<Float> values) {
            addCriterion("total_nca in", values, "totalNca");
            return (Criteria) this;
        }

        public Criteria andTotalNcaNotIn(List<Float> values) {
            addCriterion("total_nca not in", values, "totalNca");
            return (Criteria) this;
        }

        public Criteria andTotalNcaBetween(Float value1, Float value2) {
            addCriterion("total_nca between", value1, value2, "totalNca");
            return (Criteria) this;
        }

        public Criteria andTotalNcaNotBetween(Float value1, Float value2) {
            addCriterion("total_nca not between", value1, value2, "totalNca");
            return (Criteria) this;
        }

        public Criteria andCashReserCbIsNull() {
            addCriterion("cash_reser_cb is null");
            return (Criteria) this;
        }

        public Criteria andCashReserCbIsNotNull() {
            addCriterion("cash_reser_cb is not null");
            return (Criteria) this;
        }

        public Criteria andCashReserCbEqualTo(Float value) {
            addCriterion("cash_reser_cb =", value, "cashReserCb");
            return (Criteria) this;
        }

        public Criteria andCashReserCbNotEqualTo(Float value) {
            addCriterion("cash_reser_cb <>", value, "cashReserCb");
            return (Criteria) this;
        }

        public Criteria andCashReserCbGreaterThan(Float value) {
            addCriterion("cash_reser_cb >", value, "cashReserCb");
            return (Criteria) this;
        }

        public Criteria andCashReserCbGreaterThanOrEqualTo(Float value) {
            addCriterion("cash_reser_cb >=", value, "cashReserCb");
            return (Criteria) this;
        }

        public Criteria andCashReserCbLessThan(Float value) {
            addCriterion("cash_reser_cb <", value, "cashReserCb");
            return (Criteria) this;
        }

        public Criteria andCashReserCbLessThanOrEqualTo(Float value) {
            addCriterion("cash_reser_cb <=", value, "cashReserCb");
            return (Criteria) this;
        }

        public Criteria andCashReserCbIn(List<Float> values) {
            addCriterion("cash_reser_cb in", values, "cashReserCb");
            return (Criteria) this;
        }

        public Criteria andCashReserCbNotIn(List<Float> values) {
            addCriterion("cash_reser_cb not in", values, "cashReserCb");
            return (Criteria) this;
        }

        public Criteria andCashReserCbBetween(Float value1, Float value2) {
            addCriterion("cash_reser_cb between", value1, value2, "cashReserCb");
            return (Criteria) this;
        }

        public Criteria andCashReserCbNotBetween(Float value1, Float value2) {
            addCriterion("cash_reser_cb not between", value1, value2, "cashReserCb");
            return (Criteria) this;
        }

        public Criteria andDeposInOthBfiIsNull() {
            addCriterion("depos_in_oth_bfi is null");
            return (Criteria) this;
        }

        public Criteria andDeposInOthBfiIsNotNull() {
            addCriterion("depos_in_oth_bfi is not null");
            return (Criteria) this;
        }

        public Criteria andDeposInOthBfiEqualTo(Float value) {
            addCriterion("depos_in_oth_bfi =", value, "deposInOthBfi");
            return (Criteria) this;
        }

        public Criteria andDeposInOthBfiNotEqualTo(Float value) {
            addCriterion("depos_in_oth_bfi <>", value, "deposInOthBfi");
            return (Criteria) this;
        }

        public Criteria andDeposInOthBfiGreaterThan(Float value) {
            addCriterion("depos_in_oth_bfi >", value, "deposInOthBfi");
            return (Criteria) this;
        }

        public Criteria andDeposInOthBfiGreaterThanOrEqualTo(Float value) {
            addCriterion("depos_in_oth_bfi >=", value, "deposInOthBfi");
            return (Criteria) this;
        }

        public Criteria andDeposInOthBfiLessThan(Float value) {
            addCriterion("depos_in_oth_bfi <", value, "deposInOthBfi");
            return (Criteria) this;
        }

        public Criteria andDeposInOthBfiLessThanOrEqualTo(Float value) {
            addCriterion("depos_in_oth_bfi <=", value, "deposInOthBfi");
            return (Criteria) this;
        }

        public Criteria andDeposInOthBfiIn(List<Float> values) {
            addCriterion("depos_in_oth_bfi in", values, "deposInOthBfi");
            return (Criteria) this;
        }

        public Criteria andDeposInOthBfiNotIn(List<Float> values) {
            addCriterion("depos_in_oth_bfi not in", values, "deposInOthBfi");
            return (Criteria) this;
        }

        public Criteria andDeposInOthBfiBetween(Float value1, Float value2) {
            addCriterion("depos_in_oth_bfi between", value1, value2, "deposInOthBfi");
            return (Criteria) this;
        }

        public Criteria andDeposInOthBfiNotBetween(Float value1, Float value2) {
            addCriterion("depos_in_oth_bfi not between", value1, value2, "deposInOthBfi");
            return (Criteria) this;
        }

        public Criteria andPrecMetalsIsNull() {
            addCriterion("prec_metals is null");
            return (Criteria) this;
        }

        public Criteria andPrecMetalsIsNotNull() {
            addCriterion("prec_metals is not null");
            return (Criteria) this;
        }

        public Criteria andPrecMetalsEqualTo(Float value) {
            addCriterion("prec_metals =", value, "precMetals");
            return (Criteria) this;
        }

        public Criteria andPrecMetalsNotEqualTo(Float value) {
            addCriterion("prec_metals <>", value, "precMetals");
            return (Criteria) this;
        }

        public Criteria andPrecMetalsGreaterThan(Float value) {
            addCriterion("prec_metals >", value, "precMetals");
            return (Criteria) this;
        }

        public Criteria andPrecMetalsGreaterThanOrEqualTo(Float value) {
            addCriterion("prec_metals >=", value, "precMetals");
            return (Criteria) this;
        }

        public Criteria andPrecMetalsLessThan(Float value) {
            addCriterion("prec_metals <", value, "precMetals");
            return (Criteria) this;
        }

        public Criteria andPrecMetalsLessThanOrEqualTo(Float value) {
            addCriterion("prec_metals <=", value, "precMetals");
            return (Criteria) this;
        }

        public Criteria andPrecMetalsIn(List<Float> values) {
            addCriterion("prec_metals in", values, "precMetals");
            return (Criteria) this;
        }

        public Criteria andPrecMetalsNotIn(List<Float> values) {
            addCriterion("prec_metals not in", values, "precMetals");
            return (Criteria) this;
        }

        public Criteria andPrecMetalsBetween(Float value1, Float value2) {
            addCriterion("prec_metals between", value1, value2, "precMetals");
            return (Criteria) this;
        }

        public Criteria andPrecMetalsNotBetween(Float value1, Float value2) {
            addCriterion("prec_metals not between", value1, value2, "precMetals");
            return (Criteria) this;
        }

        public Criteria andDerivAssetsIsNull() {
            addCriterion("deriv_assets is null");
            return (Criteria) this;
        }

        public Criteria andDerivAssetsIsNotNull() {
            addCriterion("deriv_assets is not null");
            return (Criteria) this;
        }

        public Criteria andDerivAssetsEqualTo(Float value) {
            addCriterion("deriv_assets =", value, "derivAssets");
            return (Criteria) this;
        }

        public Criteria andDerivAssetsNotEqualTo(Float value) {
            addCriterion("deriv_assets <>", value, "derivAssets");
            return (Criteria) this;
        }

        public Criteria andDerivAssetsGreaterThan(Float value) {
            addCriterion("deriv_assets >", value, "derivAssets");
            return (Criteria) this;
        }

        public Criteria andDerivAssetsGreaterThanOrEqualTo(Float value) {
            addCriterion("deriv_assets >=", value, "derivAssets");
            return (Criteria) this;
        }

        public Criteria andDerivAssetsLessThan(Float value) {
            addCriterion("deriv_assets <", value, "derivAssets");
            return (Criteria) this;
        }

        public Criteria andDerivAssetsLessThanOrEqualTo(Float value) {
            addCriterion("deriv_assets <=", value, "derivAssets");
            return (Criteria) this;
        }

        public Criteria andDerivAssetsIn(List<Float> values) {
            addCriterion("deriv_assets in", values, "derivAssets");
            return (Criteria) this;
        }

        public Criteria andDerivAssetsNotIn(List<Float> values) {
            addCriterion("deriv_assets not in", values, "derivAssets");
            return (Criteria) this;
        }

        public Criteria andDerivAssetsBetween(Float value1, Float value2) {
            addCriterion("deriv_assets between", value1, value2, "derivAssets");
            return (Criteria) this;
        }

        public Criteria andDerivAssetsNotBetween(Float value1, Float value2) {
            addCriterion("deriv_assets not between", value1, value2, "derivAssets");
            return (Criteria) this;
        }

        public Criteria andRrReinsUnePremIsNull() {
            addCriterion("rr_reins_une_prem is null");
            return (Criteria) this;
        }

        public Criteria andRrReinsUnePremIsNotNull() {
            addCriterion("rr_reins_une_prem is not null");
            return (Criteria) this;
        }

        public Criteria andRrReinsUnePremEqualTo(Float value) {
            addCriterion("rr_reins_une_prem =", value, "rrReinsUnePrem");
            return (Criteria) this;
        }

        public Criteria andRrReinsUnePremNotEqualTo(Float value) {
            addCriterion("rr_reins_une_prem <>", value, "rrReinsUnePrem");
            return (Criteria) this;
        }

        public Criteria andRrReinsUnePremGreaterThan(Float value) {
            addCriterion("rr_reins_une_prem >", value, "rrReinsUnePrem");
            return (Criteria) this;
        }

        public Criteria andRrReinsUnePremGreaterThanOrEqualTo(Float value) {
            addCriterion("rr_reins_une_prem >=", value, "rrReinsUnePrem");
            return (Criteria) this;
        }

        public Criteria andRrReinsUnePremLessThan(Float value) {
            addCriterion("rr_reins_une_prem <", value, "rrReinsUnePrem");
            return (Criteria) this;
        }

        public Criteria andRrReinsUnePremLessThanOrEqualTo(Float value) {
            addCriterion("rr_reins_une_prem <=", value, "rrReinsUnePrem");
            return (Criteria) this;
        }

        public Criteria andRrReinsUnePremIn(List<Float> values) {
            addCriterion("rr_reins_une_prem in", values, "rrReinsUnePrem");
            return (Criteria) this;
        }

        public Criteria andRrReinsUnePremNotIn(List<Float> values) {
            addCriterion("rr_reins_une_prem not in", values, "rrReinsUnePrem");
            return (Criteria) this;
        }

        public Criteria andRrReinsUnePremBetween(Float value1, Float value2) {
            addCriterion("rr_reins_une_prem between", value1, value2, "rrReinsUnePrem");
            return (Criteria) this;
        }

        public Criteria andRrReinsUnePremNotBetween(Float value1, Float value2) {
            addCriterion("rr_reins_une_prem not between", value1, value2, "rrReinsUnePrem");
            return (Criteria) this;
        }

        public Criteria andRrReinsOutstdClaIsNull() {
            addCriterion("rr_reins_outstd_cla is null");
            return (Criteria) this;
        }

        public Criteria andRrReinsOutstdClaIsNotNull() {
            addCriterion("rr_reins_outstd_cla is not null");
            return (Criteria) this;
        }

        public Criteria andRrReinsOutstdClaEqualTo(Float value) {
            addCriterion("rr_reins_outstd_cla =", value, "rrReinsOutstdCla");
            return (Criteria) this;
        }

        public Criteria andRrReinsOutstdClaNotEqualTo(Float value) {
            addCriterion("rr_reins_outstd_cla <>", value, "rrReinsOutstdCla");
            return (Criteria) this;
        }

        public Criteria andRrReinsOutstdClaGreaterThan(Float value) {
            addCriterion("rr_reins_outstd_cla >", value, "rrReinsOutstdCla");
            return (Criteria) this;
        }

        public Criteria andRrReinsOutstdClaGreaterThanOrEqualTo(Float value) {
            addCriterion("rr_reins_outstd_cla >=", value, "rrReinsOutstdCla");
            return (Criteria) this;
        }

        public Criteria andRrReinsOutstdClaLessThan(Float value) {
            addCriterion("rr_reins_outstd_cla <", value, "rrReinsOutstdCla");
            return (Criteria) this;
        }

        public Criteria andRrReinsOutstdClaLessThanOrEqualTo(Float value) {
            addCriterion("rr_reins_outstd_cla <=", value, "rrReinsOutstdCla");
            return (Criteria) this;
        }

        public Criteria andRrReinsOutstdClaIn(List<Float> values) {
            addCriterion("rr_reins_outstd_cla in", values, "rrReinsOutstdCla");
            return (Criteria) this;
        }

        public Criteria andRrReinsOutstdClaNotIn(List<Float> values) {
            addCriterion("rr_reins_outstd_cla not in", values, "rrReinsOutstdCla");
            return (Criteria) this;
        }

        public Criteria andRrReinsOutstdClaBetween(Float value1, Float value2) {
            addCriterion("rr_reins_outstd_cla between", value1, value2, "rrReinsOutstdCla");
            return (Criteria) this;
        }

        public Criteria andRrReinsOutstdClaNotBetween(Float value1, Float value2) {
            addCriterion("rr_reins_outstd_cla not between", value1, value2, "rrReinsOutstdCla");
            return (Criteria) this;
        }

        public Criteria andRrReinsLinsLiabIsNull() {
            addCriterion("rr_reins_lins_liab is null");
            return (Criteria) this;
        }

        public Criteria andRrReinsLinsLiabIsNotNull() {
            addCriterion("rr_reins_lins_liab is not null");
            return (Criteria) this;
        }

        public Criteria andRrReinsLinsLiabEqualTo(Float value) {
            addCriterion("rr_reins_lins_liab =", value, "rrReinsLinsLiab");
            return (Criteria) this;
        }

        public Criteria andRrReinsLinsLiabNotEqualTo(Float value) {
            addCriterion("rr_reins_lins_liab <>", value, "rrReinsLinsLiab");
            return (Criteria) this;
        }

        public Criteria andRrReinsLinsLiabGreaterThan(Float value) {
            addCriterion("rr_reins_lins_liab >", value, "rrReinsLinsLiab");
            return (Criteria) this;
        }

        public Criteria andRrReinsLinsLiabGreaterThanOrEqualTo(Float value) {
            addCriterion("rr_reins_lins_liab >=", value, "rrReinsLinsLiab");
            return (Criteria) this;
        }

        public Criteria andRrReinsLinsLiabLessThan(Float value) {
            addCriterion("rr_reins_lins_liab <", value, "rrReinsLinsLiab");
            return (Criteria) this;
        }

        public Criteria andRrReinsLinsLiabLessThanOrEqualTo(Float value) {
            addCriterion("rr_reins_lins_liab <=", value, "rrReinsLinsLiab");
            return (Criteria) this;
        }

        public Criteria andRrReinsLinsLiabIn(List<Float> values) {
            addCriterion("rr_reins_lins_liab in", values, "rrReinsLinsLiab");
            return (Criteria) this;
        }

        public Criteria andRrReinsLinsLiabNotIn(List<Float> values) {
            addCriterion("rr_reins_lins_liab not in", values, "rrReinsLinsLiab");
            return (Criteria) this;
        }

        public Criteria andRrReinsLinsLiabBetween(Float value1, Float value2) {
            addCriterion("rr_reins_lins_liab between", value1, value2, "rrReinsLinsLiab");
            return (Criteria) this;
        }

        public Criteria andRrReinsLinsLiabNotBetween(Float value1, Float value2) {
            addCriterion("rr_reins_lins_liab not between", value1, value2, "rrReinsLinsLiab");
            return (Criteria) this;
        }

        public Criteria andRrReinsLthinsLiabIsNull() {
            addCriterion("rr_reins_lthins_liab is null");
            return (Criteria) this;
        }

        public Criteria andRrReinsLthinsLiabIsNotNull() {
            addCriterion("rr_reins_lthins_liab is not null");
            return (Criteria) this;
        }

        public Criteria andRrReinsLthinsLiabEqualTo(Float value) {
            addCriterion("rr_reins_lthins_liab =", value, "rrReinsLthinsLiab");
            return (Criteria) this;
        }

        public Criteria andRrReinsLthinsLiabNotEqualTo(Float value) {
            addCriterion("rr_reins_lthins_liab <>", value, "rrReinsLthinsLiab");
            return (Criteria) this;
        }

        public Criteria andRrReinsLthinsLiabGreaterThan(Float value) {
            addCriterion("rr_reins_lthins_liab >", value, "rrReinsLthinsLiab");
            return (Criteria) this;
        }

        public Criteria andRrReinsLthinsLiabGreaterThanOrEqualTo(Float value) {
            addCriterion("rr_reins_lthins_liab >=", value, "rrReinsLthinsLiab");
            return (Criteria) this;
        }

        public Criteria andRrReinsLthinsLiabLessThan(Float value) {
            addCriterion("rr_reins_lthins_liab <", value, "rrReinsLthinsLiab");
            return (Criteria) this;
        }

        public Criteria andRrReinsLthinsLiabLessThanOrEqualTo(Float value) {
            addCriterion("rr_reins_lthins_liab <=", value, "rrReinsLthinsLiab");
            return (Criteria) this;
        }

        public Criteria andRrReinsLthinsLiabIn(List<Float> values) {
            addCriterion("rr_reins_lthins_liab in", values, "rrReinsLthinsLiab");
            return (Criteria) this;
        }

        public Criteria andRrReinsLthinsLiabNotIn(List<Float> values) {
            addCriterion("rr_reins_lthins_liab not in", values, "rrReinsLthinsLiab");
            return (Criteria) this;
        }

        public Criteria andRrReinsLthinsLiabBetween(Float value1, Float value2) {
            addCriterion("rr_reins_lthins_liab between", value1, value2, "rrReinsLthinsLiab");
            return (Criteria) this;
        }

        public Criteria andRrReinsLthinsLiabNotBetween(Float value1, Float value2) {
            addCriterion("rr_reins_lthins_liab not between", value1, value2, "rrReinsLthinsLiab");
            return (Criteria) this;
        }

        public Criteria andRefundDeposIsNull() {
            addCriterion("refund_depos is null");
            return (Criteria) this;
        }

        public Criteria andRefundDeposIsNotNull() {
            addCriterion("refund_depos is not null");
            return (Criteria) this;
        }

        public Criteria andRefundDeposEqualTo(Float value) {
            addCriterion("refund_depos =", value, "refundDepos");
            return (Criteria) this;
        }

        public Criteria andRefundDeposNotEqualTo(Float value) {
            addCriterion("refund_depos <>", value, "refundDepos");
            return (Criteria) this;
        }

        public Criteria andRefundDeposGreaterThan(Float value) {
            addCriterion("refund_depos >", value, "refundDepos");
            return (Criteria) this;
        }

        public Criteria andRefundDeposGreaterThanOrEqualTo(Float value) {
            addCriterion("refund_depos >=", value, "refundDepos");
            return (Criteria) this;
        }

        public Criteria andRefundDeposLessThan(Float value) {
            addCriterion("refund_depos <", value, "refundDepos");
            return (Criteria) this;
        }

        public Criteria andRefundDeposLessThanOrEqualTo(Float value) {
            addCriterion("refund_depos <=", value, "refundDepos");
            return (Criteria) this;
        }

        public Criteria andRefundDeposIn(List<Float> values) {
            addCriterion("refund_depos in", values, "refundDepos");
            return (Criteria) this;
        }

        public Criteria andRefundDeposNotIn(List<Float> values) {
            addCriterion("refund_depos not in", values, "refundDepos");
            return (Criteria) this;
        }

        public Criteria andRefundDeposBetween(Float value1, Float value2) {
            addCriterion("refund_depos between", value1, value2, "refundDepos");
            return (Criteria) this;
        }

        public Criteria andRefundDeposNotBetween(Float value1, Float value2) {
            addCriterion("refund_depos not between", value1, value2, "refundDepos");
            return (Criteria) this;
        }

        public Criteria andPhPledgeLoansIsNull() {
            addCriterion("ph_pledge_loans is null");
            return (Criteria) this;
        }

        public Criteria andPhPledgeLoansIsNotNull() {
            addCriterion("ph_pledge_loans is not null");
            return (Criteria) this;
        }

        public Criteria andPhPledgeLoansEqualTo(Float value) {
            addCriterion("ph_pledge_loans =", value, "phPledgeLoans");
            return (Criteria) this;
        }

        public Criteria andPhPledgeLoansNotEqualTo(Float value) {
            addCriterion("ph_pledge_loans <>", value, "phPledgeLoans");
            return (Criteria) this;
        }

        public Criteria andPhPledgeLoansGreaterThan(Float value) {
            addCriterion("ph_pledge_loans >", value, "phPledgeLoans");
            return (Criteria) this;
        }

        public Criteria andPhPledgeLoansGreaterThanOrEqualTo(Float value) {
            addCriterion("ph_pledge_loans >=", value, "phPledgeLoans");
            return (Criteria) this;
        }

        public Criteria andPhPledgeLoansLessThan(Float value) {
            addCriterion("ph_pledge_loans <", value, "phPledgeLoans");
            return (Criteria) this;
        }

        public Criteria andPhPledgeLoansLessThanOrEqualTo(Float value) {
            addCriterion("ph_pledge_loans <=", value, "phPledgeLoans");
            return (Criteria) this;
        }

        public Criteria andPhPledgeLoansIn(List<Float> values) {
            addCriterion("ph_pledge_loans in", values, "phPledgeLoans");
            return (Criteria) this;
        }

        public Criteria andPhPledgeLoansNotIn(List<Float> values) {
            addCriterion("ph_pledge_loans not in", values, "phPledgeLoans");
            return (Criteria) this;
        }

        public Criteria andPhPledgeLoansBetween(Float value1, Float value2) {
            addCriterion("ph_pledge_loans between", value1, value2, "phPledgeLoans");
            return (Criteria) this;
        }

        public Criteria andPhPledgeLoansNotBetween(Float value1, Float value2) {
            addCriterion("ph_pledge_loans not between", value1, value2, "phPledgeLoans");
            return (Criteria) this;
        }

        public Criteria andRefundCapDeposIsNull() {
            addCriterion("refund_cap_depos is null");
            return (Criteria) this;
        }

        public Criteria andRefundCapDeposIsNotNull() {
            addCriterion("refund_cap_depos is not null");
            return (Criteria) this;
        }

        public Criteria andRefundCapDeposEqualTo(Float value) {
            addCriterion("refund_cap_depos =", value, "refundCapDepos");
            return (Criteria) this;
        }

        public Criteria andRefundCapDeposNotEqualTo(Float value) {
            addCriterion("refund_cap_depos <>", value, "refundCapDepos");
            return (Criteria) this;
        }

        public Criteria andRefundCapDeposGreaterThan(Float value) {
            addCriterion("refund_cap_depos >", value, "refundCapDepos");
            return (Criteria) this;
        }

        public Criteria andRefundCapDeposGreaterThanOrEqualTo(Float value) {
            addCriterion("refund_cap_depos >=", value, "refundCapDepos");
            return (Criteria) this;
        }

        public Criteria andRefundCapDeposLessThan(Float value) {
            addCriterion("refund_cap_depos <", value, "refundCapDepos");
            return (Criteria) this;
        }

        public Criteria andRefundCapDeposLessThanOrEqualTo(Float value) {
            addCriterion("refund_cap_depos <=", value, "refundCapDepos");
            return (Criteria) this;
        }

        public Criteria andRefundCapDeposIn(List<Float> values) {
            addCriterion("refund_cap_depos in", values, "refundCapDepos");
            return (Criteria) this;
        }

        public Criteria andRefundCapDeposNotIn(List<Float> values) {
            addCriterion("refund_cap_depos not in", values, "refundCapDepos");
            return (Criteria) this;
        }

        public Criteria andRefundCapDeposBetween(Float value1, Float value2) {
            addCriterion("refund_cap_depos between", value1, value2, "refundCapDepos");
            return (Criteria) this;
        }

        public Criteria andRefundCapDeposNotBetween(Float value1, Float value2) {
            addCriterion("refund_cap_depos not between", value1, value2, "refundCapDepos");
            return (Criteria) this;
        }

        public Criteria andIndepAcctAssetsIsNull() {
            addCriterion("indep_acct_assets is null");
            return (Criteria) this;
        }

        public Criteria andIndepAcctAssetsIsNotNull() {
            addCriterion("indep_acct_assets is not null");
            return (Criteria) this;
        }

        public Criteria andIndepAcctAssetsEqualTo(Float value) {
            addCriterion("indep_acct_assets =", value, "indepAcctAssets");
            return (Criteria) this;
        }

        public Criteria andIndepAcctAssetsNotEqualTo(Float value) {
            addCriterion("indep_acct_assets <>", value, "indepAcctAssets");
            return (Criteria) this;
        }

        public Criteria andIndepAcctAssetsGreaterThan(Float value) {
            addCriterion("indep_acct_assets >", value, "indepAcctAssets");
            return (Criteria) this;
        }

        public Criteria andIndepAcctAssetsGreaterThanOrEqualTo(Float value) {
            addCriterion("indep_acct_assets >=", value, "indepAcctAssets");
            return (Criteria) this;
        }

        public Criteria andIndepAcctAssetsLessThan(Float value) {
            addCriterion("indep_acct_assets <", value, "indepAcctAssets");
            return (Criteria) this;
        }

        public Criteria andIndepAcctAssetsLessThanOrEqualTo(Float value) {
            addCriterion("indep_acct_assets <=", value, "indepAcctAssets");
            return (Criteria) this;
        }

        public Criteria andIndepAcctAssetsIn(List<Float> values) {
            addCriterion("indep_acct_assets in", values, "indepAcctAssets");
            return (Criteria) this;
        }

        public Criteria andIndepAcctAssetsNotIn(List<Float> values) {
            addCriterion("indep_acct_assets not in", values, "indepAcctAssets");
            return (Criteria) this;
        }

        public Criteria andIndepAcctAssetsBetween(Float value1, Float value2) {
            addCriterion("indep_acct_assets between", value1, value2, "indepAcctAssets");
            return (Criteria) this;
        }

        public Criteria andIndepAcctAssetsNotBetween(Float value1, Float value2) {
            addCriterion("indep_acct_assets not between", value1, value2, "indepAcctAssets");
            return (Criteria) this;
        }

        public Criteria andClientDeposIsNull() {
            addCriterion("client_depos is null");
            return (Criteria) this;
        }

        public Criteria andClientDeposIsNotNull() {
            addCriterion("client_depos is not null");
            return (Criteria) this;
        }

        public Criteria andClientDeposEqualTo(Float value) {
            addCriterion("client_depos =", value, "clientDepos");
            return (Criteria) this;
        }

        public Criteria andClientDeposNotEqualTo(Float value) {
            addCriterion("client_depos <>", value, "clientDepos");
            return (Criteria) this;
        }

        public Criteria andClientDeposGreaterThan(Float value) {
            addCriterion("client_depos >", value, "clientDepos");
            return (Criteria) this;
        }

        public Criteria andClientDeposGreaterThanOrEqualTo(Float value) {
            addCriterion("client_depos >=", value, "clientDepos");
            return (Criteria) this;
        }

        public Criteria andClientDeposLessThan(Float value) {
            addCriterion("client_depos <", value, "clientDepos");
            return (Criteria) this;
        }

        public Criteria andClientDeposLessThanOrEqualTo(Float value) {
            addCriterion("client_depos <=", value, "clientDepos");
            return (Criteria) this;
        }

        public Criteria andClientDeposIn(List<Float> values) {
            addCriterion("client_depos in", values, "clientDepos");
            return (Criteria) this;
        }

        public Criteria andClientDeposNotIn(List<Float> values) {
            addCriterion("client_depos not in", values, "clientDepos");
            return (Criteria) this;
        }

        public Criteria andClientDeposBetween(Float value1, Float value2) {
            addCriterion("client_depos between", value1, value2, "clientDepos");
            return (Criteria) this;
        }

        public Criteria andClientDeposNotBetween(Float value1, Float value2) {
            addCriterion("client_depos not between", value1, value2, "clientDepos");
            return (Criteria) this;
        }

        public Criteria andClientProvIsNull() {
            addCriterion("client_prov is null");
            return (Criteria) this;
        }

        public Criteria andClientProvIsNotNull() {
            addCriterion("client_prov is not null");
            return (Criteria) this;
        }

        public Criteria andClientProvEqualTo(Float value) {
            addCriterion("client_prov =", value, "clientProv");
            return (Criteria) this;
        }

        public Criteria andClientProvNotEqualTo(Float value) {
            addCriterion("client_prov <>", value, "clientProv");
            return (Criteria) this;
        }

        public Criteria andClientProvGreaterThan(Float value) {
            addCriterion("client_prov >", value, "clientProv");
            return (Criteria) this;
        }

        public Criteria andClientProvGreaterThanOrEqualTo(Float value) {
            addCriterion("client_prov >=", value, "clientProv");
            return (Criteria) this;
        }

        public Criteria andClientProvLessThan(Float value) {
            addCriterion("client_prov <", value, "clientProv");
            return (Criteria) this;
        }

        public Criteria andClientProvLessThanOrEqualTo(Float value) {
            addCriterion("client_prov <=", value, "clientProv");
            return (Criteria) this;
        }

        public Criteria andClientProvIn(List<Float> values) {
            addCriterion("client_prov in", values, "clientProv");
            return (Criteria) this;
        }

        public Criteria andClientProvNotIn(List<Float> values) {
            addCriterion("client_prov not in", values, "clientProv");
            return (Criteria) this;
        }

        public Criteria andClientProvBetween(Float value1, Float value2) {
            addCriterion("client_prov between", value1, value2, "clientProv");
            return (Criteria) this;
        }

        public Criteria andClientProvNotBetween(Float value1, Float value2) {
            addCriterion("client_prov not between", value1, value2, "clientProv");
            return (Criteria) this;
        }

        public Criteria andTransacSeatFeeIsNull() {
            addCriterion("transac_seat_fee is null");
            return (Criteria) this;
        }

        public Criteria andTransacSeatFeeIsNotNull() {
            addCriterion("transac_seat_fee is not null");
            return (Criteria) this;
        }

        public Criteria andTransacSeatFeeEqualTo(Float value) {
            addCriterion("transac_seat_fee =", value, "transacSeatFee");
            return (Criteria) this;
        }

        public Criteria andTransacSeatFeeNotEqualTo(Float value) {
            addCriterion("transac_seat_fee <>", value, "transacSeatFee");
            return (Criteria) this;
        }

        public Criteria andTransacSeatFeeGreaterThan(Float value) {
            addCriterion("transac_seat_fee >", value, "transacSeatFee");
            return (Criteria) this;
        }

        public Criteria andTransacSeatFeeGreaterThanOrEqualTo(Float value) {
            addCriterion("transac_seat_fee >=", value, "transacSeatFee");
            return (Criteria) this;
        }

        public Criteria andTransacSeatFeeLessThan(Float value) {
            addCriterion("transac_seat_fee <", value, "transacSeatFee");
            return (Criteria) this;
        }

        public Criteria andTransacSeatFeeLessThanOrEqualTo(Float value) {
            addCriterion("transac_seat_fee <=", value, "transacSeatFee");
            return (Criteria) this;
        }

        public Criteria andTransacSeatFeeIn(List<Float> values) {
            addCriterion("transac_seat_fee in", values, "transacSeatFee");
            return (Criteria) this;
        }

        public Criteria andTransacSeatFeeNotIn(List<Float> values) {
            addCriterion("transac_seat_fee not in", values, "transacSeatFee");
            return (Criteria) this;
        }

        public Criteria andTransacSeatFeeBetween(Float value1, Float value2) {
            addCriterion("transac_seat_fee between", value1, value2, "transacSeatFee");
            return (Criteria) this;
        }

        public Criteria andTransacSeatFeeNotBetween(Float value1, Float value2) {
            addCriterion("transac_seat_fee not between", value1, value2, "transacSeatFee");
            return (Criteria) this;
        }

        public Criteria andInvestAsReceivIsNull() {
            addCriterion("invest_as_receiv is null");
            return (Criteria) this;
        }

        public Criteria andInvestAsReceivIsNotNull() {
            addCriterion("invest_as_receiv is not null");
            return (Criteria) this;
        }

        public Criteria andInvestAsReceivEqualTo(Float value) {
            addCriterion("invest_as_receiv =", value, "investAsReceiv");
            return (Criteria) this;
        }

        public Criteria andInvestAsReceivNotEqualTo(Float value) {
            addCriterion("invest_as_receiv <>", value, "investAsReceiv");
            return (Criteria) this;
        }

        public Criteria andInvestAsReceivGreaterThan(Float value) {
            addCriterion("invest_as_receiv >", value, "investAsReceiv");
            return (Criteria) this;
        }

        public Criteria andInvestAsReceivGreaterThanOrEqualTo(Float value) {
            addCriterion("invest_as_receiv >=", value, "investAsReceiv");
            return (Criteria) this;
        }

        public Criteria andInvestAsReceivLessThan(Float value) {
            addCriterion("invest_as_receiv <", value, "investAsReceiv");
            return (Criteria) this;
        }

        public Criteria andInvestAsReceivLessThanOrEqualTo(Float value) {
            addCriterion("invest_as_receiv <=", value, "investAsReceiv");
            return (Criteria) this;
        }

        public Criteria andInvestAsReceivIn(List<Float> values) {
            addCriterion("invest_as_receiv in", values, "investAsReceiv");
            return (Criteria) this;
        }

        public Criteria andInvestAsReceivNotIn(List<Float> values) {
            addCriterion("invest_as_receiv not in", values, "investAsReceiv");
            return (Criteria) this;
        }

        public Criteria andInvestAsReceivBetween(Float value1, Float value2) {
            addCriterion("invest_as_receiv between", value1, value2, "investAsReceiv");
            return (Criteria) this;
        }

        public Criteria andInvestAsReceivNotBetween(Float value1, Float value2) {
            addCriterion("invest_as_receiv not between", value1, value2, "investAsReceiv");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsIsNull() {
            addCriterion("total_assets is null");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsIsNotNull() {
            addCriterion("total_assets is not null");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsEqualTo(Float value) {
            addCriterion("total_assets =", value, "totalAssets");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsNotEqualTo(Float value) {
            addCriterion("total_assets <>", value, "totalAssets");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsGreaterThan(Float value) {
            addCriterion("total_assets >", value, "totalAssets");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsGreaterThanOrEqualTo(Float value) {
            addCriterion("total_assets >=", value, "totalAssets");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsLessThan(Float value) {
            addCriterion("total_assets <", value, "totalAssets");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsLessThanOrEqualTo(Float value) {
            addCriterion("total_assets <=", value, "totalAssets");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsIn(List<Float> values) {
            addCriterion("total_assets in", values, "totalAssets");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsNotIn(List<Float> values) {
            addCriterion("total_assets not in", values, "totalAssets");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsBetween(Float value1, Float value2) {
            addCriterion("total_assets between", value1, value2, "totalAssets");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsNotBetween(Float value1, Float value2) {
            addCriterion("total_assets not between", value1, value2, "totalAssets");
            return (Criteria) this;
        }

        public Criteria andLtBorrIsNull() {
            addCriterion("lt_borr is null");
            return (Criteria) this;
        }

        public Criteria andLtBorrIsNotNull() {
            addCriterion("lt_borr is not null");
            return (Criteria) this;
        }

        public Criteria andLtBorrEqualTo(Float value) {
            addCriterion("lt_borr =", value, "ltBorr");
            return (Criteria) this;
        }

        public Criteria andLtBorrNotEqualTo(Float value) {
            addCriterion("lt_borr <>", value, "ltBorr");
            return (Criteria) this;
        }

        public Criteria andLtBorrGreaterThan(Float value) {
            addCriterion("lt_borr >", value, "ltBorr");
            return (Criteria) this;
        }

        public Criteria andLtBorrGreaterThanOrEqualTo(Float value) {
            addCriterion("lt_borr >=", value, "ltBorr");
            return (Criteria) this;
        }

        public Criteria andLtBorrLessThan(Float value) {
            addCriterion("lt_borr <", value, "ltBorr");
            return (Criteria) this;
        }

        public Criteria andLtBorrLessThanOrEqualTo(Float value) {
            addCriterion("lt_borr <=", value, "ltBorr");
            return (Criteria) this;
        }

        public Criteria andLtBorrIn(List<Float> values) {
            addCriterion("lt_borr in", values, "ltBorr");
            return (Criteria) this;
        }

        public Criteria andLtBorrNotIn(List<Float> values) {
            addCriterion("lt_borr not in", values, "ltBorr");
            return (Criteria) this;
        }

        public Criteria andLtBorrBetween(Float value1, Float value2) {
            addCriterion("lt_borr between", value1, value2, "ltBorr");
            return (Criteria) this;
        }

        public Criteria andLtBorrNotBetween(Float value1, Float value2) {
            addCriterion("lt_borr not between", value1, value2, "ltBorr");
            return (Criteria) this;
        }

        public Criteria andStBorrIsNull() {
            addCriterion("st_borr is null");
            return (Criteria) this;
        }

        public Criteria andStBorrIsNotNull() {
            addCriterion("st_borr is not null");
            return (Criteria) this;
        }

        public Criteria andStBorrEqualTo(Float value) {
            addCriterion("st_borr =", value, "stBorr");
            return (Criteria) this;
        }

        public Criteria andStBorrNotEqualTo(Float value) {
            addCriterion("st_borr <>", value, "stBorr");
            return (Criteria) this;
        }

        public Criteria andStBorrGreaterThan(Float value) {
            addCriterion("st_borr >", value, "stBorr");
            return (Criteria) this;
        }

        public Criteria andStBorrGreaterThanOrEqualTo(Float value) {
            addCriterion("st_borr >=", value, "stBorr");
            return (Criteria) this;
        }

        public Criteria andStBorrLessThan(Float value) {
            addCriterion("st_borr <", value, "stBorr");
            return (Criteria) this;
        }

        public Criteria andStBorrLessThanOrEqualTo(Float value) {
            addCriterion("st_borr <=", value, "stBorr");
            return (Criteria) this;
        }

        public Criteria andStBorrIn(List<Float> values) {
            addCriterion("st_borr in", values, "stBorr");
            return (Criteria) this;
        }

        public Criteria andStBorrNotIn(List<Float> values) {
            addCriterion("st_borr not in", values, "stBorr");
            return (Criteria) this;
        }

        public Criteria andStBorrBetween(Float value1, Float value2) {
            addCriterion("st_borr between", value1, value2, "stBorr");
            return (Criteria) this;
        }

        public Criteria andStBorrNotBetween(Float value1, Float value2) {
            addCriterion("st_borr not between", value1, value2, "stBorr");
            return (Criteria) this;
        }

        public Criteria andCbBorrIsNull() {
            addCriterion("cb_borr is null");
            return (Criteria) this;
        }

        public Criteria andCbBorrIsNotNull() {
            addCriterion("cb_borr is not null");
            return (Criteria) this;
        }

        public Criteria andCbBorrEqualTo(Float value) {
            addCriterion("cb_borr =", value, "cbBorr");
            return (Criteria) this;
        }

        public Criteria andCbBorrNotEqualTo(Float value) {
            addCriterion("cb_borr <>", value, "cbBorr");
            return (Criteria) this;
        }

        public Criteria andCbBorrGreaterThan(Float value) {
            addCriterion("cb_borr >", value, "cbBorr");
            return (Criteria) this;
        }

        public Criteria andCbBorrGreaterThanOrEqualTo(Float value) {
            addCriterion("cb_borr >=", value, "cbBorr");
            return (Criteria) this;
        }

        public Criteria andCbBorrLessThan(Float value) {
            addCriterion("cb_borr <", value, "cbBorr");
            return (Criteria) this;
        }

        public Criteria andCbBorrLessThanOrEqualTo(Float value) {
            addCriterion("cb_borr <=", value, "cbBorr");
            return (Criteria) this;
        }

        public Criteria andCbBorrIn(List<Float> values) {
            addCriterion("cb_borr in", values, "cbBorr");
            return (Criteria) this;
        }

        public Criteria andCbBorrNotIn(List<Float> values) {
            addCriterion("cb_borr not in", values, "cbBorr");
            return (Criteria) this;
        }

        public Criteria andCbBorrBetween(Float value1, Float value2) {
            addCriterion("cb_borr between", value1, value2, "cbBorr");
            return (Criteria) this;
        }

        public Criteria andCbBorrNotBetween(Float value1, Float value2) {
            addCriterion("cb_borr not between", value1, value2, "cbBorr");
            return (Criteria) this;
        }

        public Criteria andDeposIbDepositsIsNull() {
            addCriterion("depos_ib_deposits is null");
            return (Criteria) this;
        }

        public Criteria andDeposIbDepositsIsNotNull() {
            addCriterion("depos_ib_deposits is not null");
            return (Criteria) this;
        }

        public Criteria andDeposIbDepositsEqualTo(Float value) {
            addCriterion("depos_ib_deposits =", value, "deposIbDeposits");
            return (Criteria) this;
        }

        public Criteria andDeposIbDepositsNotEqualTo(Float value) {
            addCriterion("depos_ib_deposits <>", value, "deposIbDeposits");
            return (Criteria) this;
        }

        public Criteria andDeposIbDepositsGreaterThan(Float value) {
            addCriterion("depos_ib_deposits >", value, "deposIbDeposits");
            return (Criteria) this;
        }

        public Criteria andDeposIbDepositsGreaterThanOrEqualTo(Float value) {
            addCriterion("depos_ib_deposits >=", value, "deposIbDeposits");
            return (Criteria) this;
        }

        public Criteria andDeposIbDepositsLessThan(Float value) {
            addCriterion("depos_ib_deposits <", value, "deposIbDeposits");
            return (Criteria) this;
        }

        public Criteria andDeposIbDepositsLessThanOrEqualTo(Float value) {
            addCriterion("depos_ib_deposits <=", value, "deposIbDeposits");
            return (Criteria) this;
        }

        public Criteria andDeposIbDepositsIn(List<Float> values) {
            addCriterion("depos_ib_deposits in", values, "deposIbDeposits");
            return (Criteria) this;
        }

        public Criteria andDeposIbDepositsNotIn(List<Float> values) {
            addCriterion("depos_ib_deposits not in", values, "deposIbDeposits");
            return (Criteria) this;
        }

        public Criteria andDeposIbDepositsBetween(Float value1, Float value2) {
            addCriterion("depos_ib_deposits between", value1, value2, "deposIbDeposits");
            return (Criteria) this;
        }

        public Criteria andDeposIbDepositsNotBetween(Float value1, Float value2) {
            addCriterion("depos_ib_deposits not between", value1, value2, "deposIbDeposits");
            return (Criteria) this;
        }

        public Criteria andLoanOthBankIsNull() {
            addCriterion("loan_oth_bank is null");
            return (Criteria) this;
        }

        public Criteria andLoanOthBankIsNotNull() {
            addCriterion("loan_oth_bank is not null");
            return (Criteria) this;
        }

        public Criteria andLoanOthBankEqualTo(Float value) {
            addCriterion("loan_oth_bank =", value, "loanOthBank");
            return (Criteria) this;
        }

        public Criteria andLoanOthBankNotEqualTo(Float value) {
            addCriterion("loan_oth_bank <>", value, "loanOthBank");
            return (Criteria) this;
        }

        public Criteria andLoanOthBankGreaterThan(Float value) {
            addCriterion("loan_oth_bank >", value, "loanOthBank");
            return (Criteria) this;
        }

        public Criteria andLoanOthBankGreaterThanOrEqualTo(Float value) {
            addCriterion("loan_oth_bank >=", value, "loanOthBank");
            return (Criteria) this;
        }

        public Criteria andLoanOthBankLessThan(Float value) {
            addCriterion("loan_oth_bank <", value, "loanOthBank");
            return (Criteria) this;
        }

        public Criteria andLoanOthBankLessThanOrEqualTo(Float value) {
            addCriterion("loan_oth_bank <=", value, "loanOthBank");
            return (Criteria) this;
        }

        public Criteria andLoanOthBankIn(List<Float> values) {
            addCriterion("loan_oth_bank in", values, "loanOthBank");
            return (Criteria) this;
        }

        public Criteria andLoanOthBankNotIn(List<Float> values) {
            addCriterion("loan_oth_bank not in", values, "loanOthBank");
            return (Criteria) this;
        }

        public Criteria andLoanOthBankBetween(Float value1, Float value2) {
            addCriterion("loan_oth_bank between", value1, value2, "loanOthBank");
            return (Criteria) this;
        }

        public Criteria andLoanOthBankNotBetween(Float value1, Float value2) {
            addCriterion("loan_oth_bank not between", value1, value2, "loanOthBank");
            return (Criteria) this;
        }

        public Criteria andTradingFlIsNull() {
            addCriterion("trading_fl is null");
            return (Criteria) this;
        }

        public Criteria andTradingFlIsNotNull() {
            addCriterion("trading_fl is not null");
            return (Criteria) this;
        }

        public Criteria andTradingFlEqualTo(Float value) {
            addCriterion("trading_fl =", value, "tradingFl");
            return (Criteria) this;
        }

        public Criteria andTradingFlNotEqualTo(Float value) {
            addCriterion("trading_fl <>", value, "tradingFl");
            return (Criteria) this;
        }

        public Criteria andTradingFlGreaterThan(Float value) {
            addCriterion("trading_fl >", value, "tradingFl");
            return (Criteria) this;
        }

        public Criteria andTradingFlGreaterThanOrEqualTo(Float value) {
            addCriterion("trading_fl >=", value, "tradingFl");
            return (Criteria) this;
        }

        public Criteria andTradingFlLessThan(Float value) {
            addCriterion("trading_fl <", value, "tradingFl");
            return (Criteria) this;
        }

        public Criteria andTradingFlLessThanOrEqualTo(Float value) {
            addCriterion("trading_fl <=", value, "tradingFl");
            return (Criteria) this;
        }

        public Criteria andTradingFlIn(List<Float> values) {
            addCriterion("trading_fl in", values, "tradingFl");
            return (Criteria) this;
        }

        public Criteria andTradingFlNotIn(List<Float> values) {
            addCriterion("trading_fl not in", values, "tradingFl");
            return (Criteria) this;
        }

        public Criteria andTradingFlBetween(Float value1, Float value2) {
            addCriterion("trading_fl between", value1, value2, "tradingFl");
            return (Criteria) this;
        }

        public Criteria andTradingFlNotBetween(Float value1, Float value2) {
            addCriterion("trading_fl not between", value1, value2, "tradingFl");
            return (Criteria) this;
        }

        public Criteria andNotesPayableIsNull() {
            addCriterion("notes_payable is null");
            return (Criteria) this;
        }

        public Criteria andNotesPayableIsNotNull() {
            addCriterion("notes_payable is not null");
            return (Criteria) this;
        }

        public Criteria andNotesPayableEqualTo(Float value) {
            addCriterion("notes_payable =", value, "notesPayable");
            return (Criteria) this;
        }

        public Criteria andNotesPayableNotEqualTo(Float value) {
            addCriterion("notes_payable <>", value, "notesPayable");
            return (Criteria) this;
        }

        public Criteria andNotesPayableGreaterThan(Float value) {
            addCriterion("notes_payable >", value, "notesPayable");
            return (Criteria) this;
        }

        public Criteria andNotesPayableGreaterThanOrEqualTo(Float value) {
            addCriterion("notes_payable >=", value, "notesPayable");
            return (Criteria) this;
        }

        public Criteria andNotesPayableLessThan(Float value) {
            addCriterion("notes_payable <", value, "notesPayable");
            return (Criteria) this;
        }

        public Criteria andNotesPayableLessThanOrEqualTo(Float value) {
            addCriterion("notes_payable <=", value, "notesPayable");
            return (Criteria) this;
        }

        public Criteria andNotesPayableIn(List<Float> values) {
            addCriterion("notes_payable in", values, "notesPayable");
            return (Criteria) this;
        }

        public Criteria andNotesPayableNotIn(List<Float> values) {
            addCriterion("notes_payable not in", values, "notesPayable");
            return (Criteria) this;
        }

        public Criteria andNotesPayableBetween(Float value1, Float value2) {
            addCriterion("notes_payable between", value1, value2, "notesPayable");
            return (Criteria) this;
        }

        public Criteria andNotesPayableNotBetween(Float value1, Float value2) {
            addCriterion("notes_payable not between", value1, value2, "notesPayable");
            return (Criteria) this;
        }

        public Criteria andAcctPayableIsNull() {
            addCriterion("acct_payable is null");
            return (Criteria) this;
        }

        public Criteria andAcctPayableIsNotNull() {
            addCriterion("acct_payable is not null");
            return (Criteria) this;
        }

        public Criteria andAcctPayableEqualTo(Float value) {
            addCriterion("acct_payable =", value, "acctPayable");
            return (Criteria) this;
        }

        public Criteria andAcctPayableNotEqualTo(Float value) {
            addCriterion("acct_payable <>", value, "acctPayable");
            return (Criteria) this;
        }

        public Criteria andAcctPayableGreaterThan(Float value) {
            addCriterion("acct_payable >", value, "acctPayable");
            return (Criteria) this;
        }

        public Criteria andAcctPayableGreaterThanOrEqualTo(Float value) {
            addCriterion("acct_payable >=", value, "acctPayable");
            return (Criteria) this;
        }

        public Criteria andAcctPayableLessThan(Float value) {
            addCriterion("acct_payable <", value, "acctPayable");
            return (Criteria) this;
        }

        public Criteria andAcctPayableLessThanOrEqualTo(Float value) {
            addCriterion("acct_payable <=", value, "acctPayable");
            return (Criteria) this;
        }

        public Criteria andAcctPayableIn(List<Float> values) {
            addCriterion("acct_payable in", values, "acctPayable");
            return (Criteria) this;
        }

        public Criteria andAcctPayableNotIn(List<Float> values) {
            addCriterion("acct_payable not in", values, "acctPayable");
            return (Criteria) this;
        }

        public Criteria andAcctPayableBetween(Float value1, Float value2) {
            addCriterion("acct_payable between", value1, value2, "acctPayable");
            return (Criteria) this;
        }

        public Criteria andAcctPayableNotBetween(Float value1, Float value2) {
            addCriterion("acct_payable not between", value1, value2, "acctPayable");
            return (Criteria) this;
        }

        public Criteria andAdvReceiptsIsNull() {
            addCriterion("adv_receipts is null");
            return (Criteria) this;
        }

        public Criteria andAdvReceiptsIsNotNull() {
            addCriterion("adv_receipts is not null");
            return (Criteria) this;
        }

        public Criteria andAdvReceiptsEqualTo(Float value) {
            addCriterion("adv_receipts =", value, "advReceipts");
            return (Criteria) this;
        }

        public Criteria andAdvReceiptsNotEqualTo(Float value) {
            addCriterion("adv_receipts <>", value, "advReceipts");
            return (Criteria) this;
        }

        public Criteria andAdvReceiptsGreaterThan(Float value) {
            addCriterion("adv_receipts >", value, "advReceipts");
            return (Criteria) this;
        }

        public Criteria andAdvReceiptsGreaterThanOrEqualTo(Float value) {
            addCriterion("adv_receipts >=", value, "advReceipts");
            return (Criteria) this;
        }

        public Criteria andAdvReceiptsLessThan(Float value) {
            addCriterion("adv_receipts <", value, "advReceipts");
            return (Criteria) this;
        }

        public Criteria andAdvReceiptsLessThanOrEqualTo(Float value) {
            addCriterion("adv_receipts <=", value, "advReceipts");
            return (Criteria) this;
        }

        public Criteria andAdvReceiptsIn(List<Float> values) {
            addCriterion("adv_receipts in", values, "advReceipts");
            return (Criteria) this;
        }

        public Criteria andAdvReceiptsNotIn(List<Float> values) {
            addCriterion("adv_receipts not in", values, "advReceipts");
            return (Criteria) this;
        }

        public Criteria andAdvReceiptsBetween(Float value1, Float value2) {
            addCriterion("adv_receipts between", value1, value2, "advReceipts");
            return (Criteria) this;
        }

        public Criteria andAdvReceiptsNotBetween(Float value1, Float value2) {
            addCriterion("adv_receipts not between", value1, value2, "advReceipts");
            return (Criteria) this;
        }

        public Criteria andSoldForRepurFaIsNull() {
            addCriterion("sold_for_repur_fa is null");
            return (Criteria) this;
        }

        public Criteria andSoldForRepurFaIsNotNull() {
            addCriterion("sold_for_repur_fa is not null");
            return (Criteria) this;
        }

        public Criteria andSoldForRepurFaEqualTo(Float value) {
            addCriterion("sold_for_repur_fa =", value, "soldForRepurFa");
            return (Criteria) this;
        }

        public Criteria andSoldForRepurFaNotEqualTo(Float value) {
            addCriterion("sold_for_repur_fa <>", value, "soldForRepurFa");
            return (Criteria) this;
        }

        public Criteria andSoldForRepurFaGreaterThan(Float value) {
            addCriterion("sold_for_repur_fa >", value, "soldForRepurFa");
            return (Criteria) this;
        }

        public Criteria andSoldForRepurFaGreaterThanOrEqualTo(Float value) {
            addCriterion("sold_for_repur_fa >=", value, "soldForRepurFa");
            return (Criteria) this;
        }

        public Criteria andSoldForRepurFaLessThan(Float value) {
            addCriterion("sold_for_repur_fa <", value, "soldForRepurFa");
            return (Criteria) this;
        }

        public Criteria andSoldForRepurFaLessThanOrEqualTo(Float value) {
            addCriterion("sold_for_repur_fa <=", value, "soldForRepurFa");
            return (Criteria) this;
        }

        public Criteria andSoldForRepurFaIn(List<Float> values) {
            addCriterion("sold_for_repur_fa in", values, "soldForRepurFa");
            return (Criteria) this;
        }

        public Criteria andSoldForRepurFaNotIn(List<Float> values) {
            addCriterion("sold_for_repur_fa not in", values, "soldForRepurFa");
            return (Criteria) this;
        }

        public Criteria andSoldForRepurFaBetween(Float value1, Float value2) {
            addCriterion("sold_for_repur_fa between", value1, value2, "soldForRepurFa");
            return (Criteria) this;
        }

        public Criteria andSoldForRepurFaNotBetween(Float value1, Float value2) {
            addCriterion("sold_for_repur_fa not between", value1, value2, "soldForRepurFa");
            return (Criteria) this;
        }

        public Criteria andCommPayableIsNull() {
            addCriterion("comm_payable is null");
            return (Criteria) this;
        }

        public Criteria andCommPayableIsNotNull() {
            addCriterion("comm_payable is not null");
            return (Criteria) this;
        }

        public Criteria andCommPayableEqualTo(Float value) {
            addCriterion("comm_payable =", value, "commPayable");
            return (Criteria) this;
        }

        public Criteria andCommPayableNotEqualTo(Float value) {
            addCriterion("comm_payable <>", value, "commPayable");
            return (Criteria) this;
        }

        public Criteria andCommPayableGreaterThan(Float value) {
            addCriterion("comm_payable >", value, "commPayable");
            return (Criteria) this;
        }

        public Criteria andCommPayableGreaterThanOrEqualTo(Float value) {
            addCriterion("comm_payable >=", value, "commPayable");
            return (Criteria) this;
        }

        public Criteria andCommPayableLessThan(Float value) {
            addCriterion("comm_payable <", value, "commPayable");
            return (Criteria) this;
        }

        public Criteria andCommPayableLessThanOrEqualTo(Float value) {
            addCriterion("comm_payable <=", value, "commPayable");
            return (Criteria) this;
        }

        public Criteria andCommPayableIn(List<Float> values) {
            addCriterion("comm_payable in", values, "commPayable");
            return (Criteria) this;
        }

        public Criteria andCommPayableNotIn(List<Float> values) {
            addCriterion("comm_payable not in", values, "commPayable");
            return (Criteria) this;
        }

        public Criteria andCommPayableBetween(Float value1, Float value2) {
            addCriterion("comm_payable between", value1, value2, "commPayable");
            return (Criteria) this;
        }

        public Criteria andCommPayableNotBetween(Float value1, Float value2) {
            addCriterion("comm_payable not between", value1, value2, "commPayable");
            return (Criteria) this;
        }

        public Criteria andPayrollPayableIsNull() {
            addCriterion("payroll_payable is null");
            return (Criteria) this;
        }

        public Criteria andPayrollPayableIsNotNull() {
            addCriterion("payroll_payable is not null");
            return (Criteria) this;
        }

        public Criteria andPayrollPayableEqualTo(Float value) {
            addCriterion("payroll_payable =", value, "payrollPayable");
            return (Criteria) this;
        }

        public Criteria andPayrollPayableNotEqualTo(Float value) {
            addCriterion("payroll_payable <>", value, "payrollPayable");
            return (Criteria) this;
        }

        public Criteria andPayrollPayableGreaterThan(Float value) {
            addCriterion("payroll_payable >", value, "payrollPayable");
            return (Criteria) this;
        }

        public Criteria andPayrollPayableGreaterThanOrEqualTo(Float value) {
            addCriterion("payroll_payable >=", value, "payrollPayable");
            return (Criteria) this;
        }

        public Criteria andPayrollPayableLessThan(Float value) {
            addCriterion("payroll_payable <", value, "payrollPayable");
            return (Criteria) this;
        }

        public Criteria andPayrollPayableLessThanOrEqualTo(Float value) {
            addCriterion("payroll_payable <=", value, "payrollPayable");
            return (Criteria) this;
        }

        public Criteria andPayrollPayableIn(List<Float> values) {
            addCriterion("payroll_payable in", values, "payrollPayable");
            return (Criteria) this;
        }

        public Criteria andPayrollPayableNotIn(List<Float> values) {
            addCriterion("payroll_payable not in", values, "payrollPayable");
            return (Criteria) this;
        }

        public Criteria andPayrollPayableBetween(Float value1, Float value2) {
            addCriterion("payroll_payable between", value1, value2, "payrollPayable");
            return (Criteria) this;
        }

        public Criteria andPayrollPayableNotBetween(Float value1, Float value2) {
            addCriterion("payroll_payable not between", value1, value2, "payrollPayable");
            return (Criteria) this;
        }

        public Criteria andTaxesPayableIsNull() {
            addCriterion("taxes_payable is null");
            return (Criteria) this;
        }

        public Criteria andTaxesPayableIsNotNull() {
            addCriterion("taxes_payable is not null");
            return (Criteria) this;
        }

        public Criteria andTaxesPayableEqualTo(Float value) {
            addCriterion("taxes_payable =", value, "taxesPayable");
            return (Criteria) this;
        }

        public Criteria andTaxesPayableNotEqualTo(Float value) {
            addCriterion("taxes_payable <>", value, "taxesPayable");
            return (Criteria) this;
        }

        public Criteria andTaxesPayableGreaterThan(Float value) {
            addCriterion("taxes_payable >", value, "taxesPayable");
            return (Criteria) this;
        }

        public Criteria andTaxesPayableGreaterThanOrEqualTo(Float value) {
            addCriterion("taxes_payable >=", value, "taxesPayable");
            return (Criteria) this;
        }

        public Criteria andTaxesPayableLessThan(Float value) {
            addCriterion("taxes_payable <", value, "taxesPayable");
            return (Criteria) this;
        }

        public Criteria andTaxesPayableLessThanOrEqualTo(Float value) {
            addCriterion("taxes_payable <=", value, "taxesPayable");
            return (Criteria) this;
        }

        public Criteria andTaxesPayableIn(List<Float> values) {
            addCriterion("taxes_payable in", values, "taxesPayable");
            return (Criteria) this;
        }

        public Criteria andTaxesPayableNotIn(List<Float> values) {
            addCriterion("taxes_payable not in", values, "taxesPayable");
            return (Criteria) this;
        }

        public Criteria andTaxesPayableBetween(Float value1, Float value2) {
            addCriterion("taxes_payable between", value1, value2, "taxesPayable");
            return (Criteria) this;
        }

        public Criteria andTaxesPayableNotBetween(Float value1, Float value2) {
            addCriterion("taxes_payable not between", value1, value2, "taxesPayable");
            return (Criteria) this;
        }

        public Criteria andIntPayableIsNull() {
            addCriterion("int_payable is null");
            return (Criteria) this;
        }

        public Criteria andIntPayableIsNotNull() {
            addCriterion("int_payable is not null");
            return (Criteria) this;
        }

        public Criteria andIntPayableEqualTo(Float value) {
            addCriterion("int_payable =", value, "intPayable");
            return (Criteria) this;
        }

        public Criteria andIntPayableNotEqualTo(Float value) {
            addCriterion("int_payable <>", value, "intPayable");
            return (Criteria) this;
        }

        public Criteria andIntPayableGreaterThan(Float value) {
            addCriterion("int_payable >", value, "intPayable");
            return (Criteria) this;
        }

        public Criteria andIntPayableGreaterThanOrEqualTo(Float value) {
            addCriterion("int_payable >=", value, "intPayable");
            return (Criteria) this;
        }

        public Criteria andIntPayableLessThan(Float value) {
            addCriterion("int_payable <", value, "intPayable");
            return (Criteria) this;
        }

        public Criteria andIntPayableLessThanOrEqualTo(Float value) {
            addCriterion("int_payable <=", value, "intPayable");
            return (Criteria) this;
        }

        public Criteria andIntPayableIn(List<Float> values) {
            addCriterion("int_payable in", values, "intPayable");
            return (Criteria) this;
        }

        public Criteria andIntPayableNotIn(List<Float> values) {
            addCriterion("int_payable not in", values, "intPayable");
            return (Criteria) this;
        }

        public Criteria andIntPayableBetween(Float value1, Float value2) {
            addCriterion("int_payable between", value1, value2, "intPayable");
            return (Criteria) this;
        }

        public Criteria andIntPayableNotBetween(Float value1, Float value2) {
            addCriterion("int_payable not between", value1, value2, "intPayable");
            return (Criteria) this;
        }

        public Criteria andDivPayableIsNull() {
            addCriterion("div_payable is null");
            return (Criteria) this;
        }

        public Criteria andDivPayableIsNotNull() {
            addCriterion("div_payable is not null");
            return (Criteria) this;
        }

        public Criteria andDivPayableEqualTo(Float value) {
            addCriterion("div_payable =", value, "divPayable");
            return (Criteria) this;
        }

        public Criteria andDivPayableNotEqualTo(Float value) {
            addCriterion("div_payable <>", value, "divPayable");
            return (Criteria) this;
        }

        public Criteria andDivPayableGreaterThan(Float value) {
            addCriterion("div_payable >", value, "divPayable");
            return (Criteria) this;
        }

        public Criteria andDivPayableGreaterThanOrEqualTo(Float value) {
            addCriterion("div_payable >=", value, "divPayable");
            return (Criteria) this;
        }

        public Criteria andDivPayableLessThan(Float value) {
            addCriterion("div_payable <", value, "divPayable");
            return (Criteria) this;
        }

        public Criteria andDivPayableLessThanOrEqualTo(Float value) {
            addCriterion("div_payable <=", value, "divPayable");
            return (Criteria) this;
        }

        public Criteria andDivPayableIn(List<Float> values) {
            addCriterion("div_payable in", values, "divPayable");
            return (Criteria) this;
        }

        public Criteria andDivPayableNotIn(List<Float> values) {
            addCriterion("div_payable not in", values, "divPayable");
            return (Criteria) this;
        }

        public Criteria andDivPayableBetween(Float value1, Float value2) {
            addCriterion("div_payable between", value1, value2, "divPayable");
            return (Criteria) this;
        }

        public Criteria andDivPayableNotBetween(Float value1, Float value2) {
            addCriterion("div_payable not between", value1, value2, "divPayable");
            return (Criteria) this;
        }

        public Criteria andOthPayableIsNull() {
            addCriterion("oth_payable is null");
            return (Criteria) this;
        }

        public Criteria andOthPayableIsNotNull() {
            addCriterion("oth_payable is not null");
            return (Criteria) this;
        }

        public Criteria andOthPayableEqualTo(Float value) {
            addCriterion("oth_payable =", value, "othPayable");
            return (Criteria) this;
        }

        public Criteria andOthPayableNotEqualTo(Float value) {
            addCriterion("oth_payable <>", value, "othPayable");
            return (Criteria) this;
        }

        public Criteria andOthPayableGreaterThan(Float value) {
            addCriterion("oth_payable >", value, "othPayable");
            return (Criteria) this;
        }

        public Criteria andOthPayableGreaterThanOrEqualTo(Float value) {
            addCriterion("oth_payable >=", value, "othPayable");
            return (Criteria) this;
        }

        public Criteria andOthPayableLessThan(Float value) {
            addCriterion("oth_payable <", value, "othPayable");
            return (Criteria) this;
        }

        public Criteria andOthPayableLessThanOrEqualTo(Float value) {
            addCriterion("oth_payable <=", value, "othPayable");
            return (Criteria) this;
        }

        public Criteria andOthPayableIn(List<Float> values) {
            addCriterion("oth_payable in", values, "othPayable");
            return (Criteria) this;
        }

        public Criteria andOthPayableNotIn(List<Float> values) {
            addCriterion("oth_payable not in", values, "othPayable");
            return (Criteria) this;
        }

        public Criteria andOthPayableBetween(Float value1, Float value2) {
            addCriterion("oth_payable between", value1, value2, "othPayable");
            return (Criteria) this;
        }

        public Criteria andOthPayableNotBetween(Float value1, Float value2) {
            addCriterion("oth_payable not between", value1, value2, "othPayable");
            return (Criteria) this;
        }

        public Criteria andAccExpIsNull() {
            addCriterion("acc_exp is null");
            return (Criteria) this;
        }

        public Criteria andAccExpIsNotNull() {
            addCriterion("acc_exp is not null");
            return (Criteria) this;
        }

        public Criteria andAccExpEqualTo(Float value) {
            addCriterion("acc_exp =", value, "accExp");
            return (Criteria) this;
        }

        public Criteria andAccExpNotEqualTo(Float value) {
            addCriterion("acc_exp <>", value, "accExp");
            return (Criteria) this;
        }

        public Criteria andAccExpGreaterThan(Float value) {
            addCriterion("acc_exp >", value, "accExp");
            return (Criteria) this;
        }

        public Criteria andAccExpGreaterThanOrEqualTo(Float value) {
            addCriterion("acc_exp >=", value, "accExp");
            return (Criteria) this;
        }

        public Criteria andAccExpLessThan(Float value) {
            addCriterion("acc_exp <", value, "accExp");
            return (Criteria) this;
        }

        public Criteria andAccExpLessThanOrEqualTo(Float value) {
            addCriterion("acc_exp <=", value, "accExp");
            return (Criteria) this;
        }

        public Criteria andAccExpIn(List<Float> values) {
            addCriterion("acc_exp in", values, "accExp");
            return (Criteria) this;
        }

        public Criteria andAccExpNotIn(List<Float> values) {
            addCriterion("acc_exp not in", values, "accExp");
            return (Criteria) this;
        }

        public Criteria andAccExpBetween(Float value1, Float value2) {
            addCriterion("acc_exp between", value1, value2, "accExp");
            return (Criteria) this;
        }

        public Criteria andAccExpNotBetween(Float value1, Float value2) {
            addCriterion("acc_exp not between", value1, value2, "accExp");
            return (Criteria) this;
        }

        public Criteria andDeferredIncIsNull() {
            addCriterion("deferred_inc is null");
            return (Criteria) this;
        }

        public Criteria andDeferredIncIsNotNull() {
            addCriterion("deferred_inc is not null");
            return (Criteria) this;
        }

        public Criteria andDeferredIncEqualTo(Float value) {
            addCriterion("deferred_inc =", value, "deferredInc");
            return (Criteria) this;
        }

        public Criteria andDeferredIncNotEqualTo(Float value) {
            addCriterion("deferred_inc <>", value, "deferredInc");
            return (Criteria) this;
        }

        public Criteria andDeferredIncGreaterThan(Float value) {
            addCriterion("deferred_inc >", value, "deferredInc");
            return (Criteria) this;
        }

        public Criteria andDeferredIncGreaterThanOrEqualTo(Float value) {
            addCriterion("deferred_inc >=", value, "deferredInc");
            return (Criteria) this;
        }

        public Criteria andDeferredIncLessThan(Float value) {
            addCriterion("deferred_inc <", value, "deferredInc");
            return (Criteria) this;
        }

        public Criteria andDeferredIncLessThanOrEqualTo(Float value) {
            addCriterion("deferred_inc <=", value, "deferredInc");
            return (Criteria) this;
        }

        public Criteria andDeferredIncIn(List<Float> values) {
            addCriterion("deferred_inc in", values, "deferredInc");
            return (Criteria) this;
        }

        public Criteria andDeferredIncNotIn(List<Float> values) {
            addCriterion("deferred_inc not in", values, "deferredInc");
            return (Criteria) this;
        }

        public Criteria andDeferredIncBetween(Float value1, Float value2) {
            addCriterion("deferred_inc between", value1, value2, "deferredInc");
            return (Criteria) this;
        }

        public Criteria andDeferredIncNotBetween(Float value1, Float value2) {
            addCriterion("deferred_inc not between", value1, value2, "deferredInc");
            return (Criteria) this;
        }

        public Criteria andStBondsPayableIsNull() {
            addCriterion("st_bonds_payable is null");
            return (Criteria) this;
        }

        public Criteria andStBondsPayableIsNotNull() {
            addCriterion("st_bonds_payable is not null");
            return (Criteria) this;
        }

        public Criteria andStBondsPayableEqualTo(Float value) {
            addCriterion("st_bonds_payable =", value, "stBondsPayable");
            return (Criteria) this;
        }

        public Criteria andStBondsPayableNotEqualTo(Float value) {
            addCriterion("st_bonds_payable <>", value, "stBondsPayable");
            return (Criteria) this;
        }

        public Criteria andStBondsPayableGreaterThan(Float value) {
            addCriterion("st_bonds_payable >", value, "stBondsPayable");
            return (Criteria) this;
        }

        public Criteria andStBondsPayableGreaterThanOrEqualTo(Float value) {
            addCriterion("st_bonds_payable >=", value, "stBondsPayable");
            return (Criteria) this;
        }

        public Criteria andStBondsPayableLessThan(Float value) {
            addCriterion("st_bonds_payable <", value, "stBondsPayable");
            return (Criteria) this;
        }

        public Criteria andStBondsPayableLessThanOrEqualTo(Float value) {
            addCriterion("st_bonds_payable <=", value, "stBondsPayable");
            return (Criteria) this;
        }

        public Criteria andStBondsPayableIn(List<Float> values) {
            addCriterion("st_bonds_payable in", values, "stBondsPayable");
            return (Criteria) this;
        }

        public Criteria andStBondsPayableNotIn(List<Float> values) {
            addCriterion("st_bonds_payable not in", values, "stBondsPayable");
            return (Criteria) this;
        }

        public Criteria andStBondsPayableBetween(Float value1, Float value2) {
            addCriterion("st_bonds_payable between", value1, value2, "stBondsPayable");
            return (Criteria) this;
        }

        public Criteria andStBondsPayableNotBetween(Float value1, Float value2) {
            addCriterion("st_bonds_payable not between", value1, value2, "stBondsPayable");
            return (Criteria) this;
        }

        public Criteria andPayableToReinsurerIsNull() {
            addCriterion("payable_to_reinsurer is null");
            return (Criteria) this;
        }

        public Criteria andPayableToReinsurerIsNotNull() {
            addCriterion("payable_to_reinsurer is not null");
            return (Criteria) this;
        }

        public Criteria andPayableToReinsurerEqualTo(Float value) {
            addCriterion("payable_to_reinsurer =", value, "payableToReinsurer");
            return (Criteria) this;
        }

        public Criteria andPayableToReinsurerNotEqualTo(Float value) {
            addCriterion("payable_to_reinsurer <>", value, "payableToReinsurer");
            return (Criteria) this;
        }

        public Criteria andPayableToReinsurerGreaterThan(Float value) {
            addCriterion("payable_to_reinsurer >", value, "payableToReinsurer");
            return (Criteria) this;
        }

        public Criteria andPayableToReinsurerGreaterThanOrEqualTo(Float value) {
            addCriterion("payable_to_reinsurer >=", value, "payableToReinsurer");
            return (Criteria) this;
        }

        public Criteria andPayableToReinsurerLessThan(Float value) {
            addCriterion("payable_to_reinsurer <", value, "payableToReinsurer");
            return (Criteria) this;
        }

        public Criteria andPayableToReinsurerLessThanOrEqualTo(Float value) {
            addCriterion("payable_to_reinsurer <=", value, "payableToReinsurer");
            return (Criteria) this;
        }

        public Criteria andPayableToReinsurerIn(List<Float> values) {
            addCriterion("payable_to_reinsurer in", values, "payableToReinsurer");
            return (Criteria) this;
        }

        public Criteria andPayableToReinsurerNotIn(List<Float> values) {
            addCriterion("payable_to_reinsurer not in", values, "payableToReinsurer");
            return (Criteria) this;
        }

        public Criteria andPayableToReinsurerBetween(Float value1, Float value2) {
            addCriterion("payable_to_reinsurer between", value1, value2, "payableToReinsurer");
            return (Criteria) this;
        }

        public Criteria andPayableToReinsurerNotBetween(Float value1, Float value2) {
            addCriterion("payable_to_reinsurer not between", value1, value2, "payableToReinsurer");
            return (Criteria) this;
        }

        public Criteria andRsrvInsurContIsNull() {
            addCriterion("rsrv_insur_cont is null");
            return (Criteria) this;
        }

        public Criteria andRsrvInsurContIsNotNull() {
            addCriterion("rsrv_insur_cont is not null");
            return (Criteria) this;
        }

        public Criteria andRsrvInsurContEqualTo(Float value) {
            addCriterion("rsrv_insur_cont =", value, "rsrvInsurCont");
            return (Criteria) this;
        }

        public Criteria andRsrvInsurContNotEqualTo(Float value) {
            addCriterion("rsrv_insur_cont <>", value, "rsrvInsurCont");
            return (Criteria) this;
        }

        public Criteria andRsrvInsurContGreaterThan(Float value) {
            addCriterion("rsrv_insur_cont >", value, "rsrvInsurCont");
            return (Criteria) this;
        }

        public Criteria andRsrvInsurContGreaterThanOrEqualTo(Float value) {
            addCriterion("rsrv_insur_cont >=", value, "rsrvInsurCont");
            return (Criteria) this;
        }

        public Criteria andRsrvInsurContLessThan(Float value) {
            addCriterion("rsrv_insur_cont <", value, "rsrvInsurCont");
            return (Criteria) this;
        }

        public Criteria andRsrvInsurContLessThanOrEqualTo(Float value) {
            addCriterion("rsrv_insur_cont <=", value, "rsrvInsurCont");
            return (Criteria) this;
        }

        public Criteria andRsrvInsurContIn(List<Float> values) {
            addCriterion("rsrv_insur_cont in", values, "rsrvInsurCont");
            return (Criteria) this;
        }

        public Criteria andRsrvInsurContNotIn(List<Float> values) {
            addCriterion("rsrv_insur_cont not in", values, "rsrvInsurCont");
            return (Criteria) this;
        }

        public Criteria andRsrvInsurContBetween(Float value1, Float value2) {
            addCriterion("rsrv_insur_cont between", value1, value2, "rsrvInsurCont");
            return (Criteria) this;
        }

        public Criteria andRsrvInsurContNotBetween(Float value1, Float value2) {
            addCriterion("rsrv_insur_cont not between", value1, value2, "rsrvInsurCont");
            return (Criteria) this;
        }

        public Criteria andActingTradingSecIsNull() {
            addCriterion("acting_trading_sec is null");
            return (Criteria) this;
        }

        public Criteria andActingTradingSecIsNotNull() {
            addCriterion("acting_trading_sec is not null");
            return (Criteria) this;
        }

        public Criteria andActingTradingSecEqualTo(Float value) {
            addCriterion("acting_trading_sec =", value, "actingTradingSec");
            return (Criteria) this;
        }

        public Criteria andActingTradingSecNotEqualTo(Float value) {
            addCriterion("acting_trading_sec <>", value, "actingTradingSec");
            return (Criteria) this;
        }

        public Criteria andActingTradingSecGreaterThan(Float value) {
            addCriterion("acting_trading_sec >", value, "actingTradingSec");
            return (Criteria) this;
        }

        public Criteria andActingTradingSecGreaterThanOrEqualTo(Float value) {
            addCriterion("acting_trading_sec >=", value, "actingTradingSec");
            return (Criteria) this;
        }

        public Criteria andActingTradingSecLessThan(Float value) {
            addCriterion("acting_trading_sec <", value, "actingTradingSec");
            return (Criteria) this;
        }

        public Criteria andActingTradingSecLessThanOrEqualTo(Float value) {
            addCriterion("acting_trading_sec <=", value, "actingTradingSec");
            return (Criteria) this;
        }

        public Criteria andActingTradingSecIn(List<Float> values) {
            addCriterion("acting_trading_sec in", values, "actingTradingSec");
            return (Criteria) this;
        }

        public Criteria andActingTradingSecNotIn(List<Float> values) {
            addCriterion("acting_trading_sec not in", values, "actingTradingSec");
            return (Criteria) this;
        }

        public Criteria andActingTradingSecBetween(Float value1, Float value2) {
            addCriterion("acting_trading_sec between", value1, value2, "actingTradingSec");
            return (Criteria) this;
        }

        public Criteria andActingTradingSecNotBetween(Float value1, Float value2) {
            addCriterion("acting_trading_sec not between", value1, value2, "actingTradingSec");
            return (Criteria) this;
        }

        public Criteria andActingUwSecIsNull() {
            addCriterion("acting_uw_sec is null");
            return (Criteria) this;
        }

        public Criteria andActingUwSecIsNotNull() {
            addCriterion("acting_uw_sec is not null");
            return (Criteria) this;
        }

        public Criteria andActingUwSecEqualTo(Float value) {
            addCriterion("acting_uw_sec =", value, "actingUwSec");
            return (Criteria) this;
        }

        public Criteria andActingUwSecNotEqualTo(Float value) {
            addCriterion("acting_uw_sec <>", value, "actingUwSec");
            return (Criteria) this;
        }

        public Criteria andActingUwSecGreaterThan(Float value) {
            addCriterion("acting_uw_sec >", value, "actingUwSec");
            return (Criteria) this;
        }

        public Criteria andActingUwSecGreaterThanOrEqualTo(Float value) {
            addCriterion("acting_uw_sec >=", value, "actingUwSec");
            return (Criteria) this;
        }

        public Criteria andActingUwSecLessThan(Float value) {
            addCriterion("acting_uw_sec <", value, "actingUwSec");
            return (Criteria) this;
        }

        public Criteria andActingUwSecLessThanOrEqualTo(Float value) {
            addCriterion("acting_uw_sec <=", value, "actingUwSec");
            return (Criteria) this;
        }

        public Criteria andActingUwSecIn(List<Float> values) {
            addCriterion("acting_uw_sec in", values, "actingUwSec");
            return (Criteria) this;
        }

        public Criteria andActingUwSecNotIn(List<Float> values) {
            addCriterion("acting_uw_sec not in", values, "actingUwSec");
            return (Criteria) this;
        }

        public Criteria andActingUwSecBetween(Float value1, Float value2) {
            addCriterion("acting_uw_sec between", value1, value2, "actingUwSec");
            return (Criteria) this;
        }

        public Criteria andActingUwSecNotBetween(Float value1, Float value2) {
            addCriterion("acting_uw_sec not between", value1, value2, "actingUwSec");
            return (Criteria) this;
        }

        public Criteria andNonCurLiabDue1yIsNull() {
            addCriterion("non_cur_liab_due_1y is null");
            return (Criteria) this;
        }

        public Criteria andNonCurLiabDue1yIsNotNull() {
            addCriterion("non_cur_liab_due_1y is not null");
            return (Criteria) this;
        }

        public Criteria andNonCurLiabDue1yEqualTo(Float value) {
            addCriterion("non_cur_liab_due_1y =", value, "nonCurLiabDue1y");
            return (Criteria) this;
        }

        public Criteria andNonCurLiabDue1yNotEqualTo(Float value) {
            addCriterion("non_cur_liab_due_1y <>", value, "nonCurLiabDue1y");
            return (Criteria) this;
        }

        public Criteria andNonCurLiabDue1yGreaterThan(Float value) {
            addCriterion("non_cur_liab_due_1y >", value, "nonCurLiabDue1y");
            return (Criteria) this;
        }

        public Criteria andNonCurLiabDue1yGreaterThanOrEqualTo(Float value) {
            addCriterion("non_cur_liab_due_1y >=", value, "nonCurLiabDue1y");
            return (Criteria) this;
        }

        public Criteria andNonCurLiabDue1yLessThan(Float value) {
            addCriterion("non_cur_liab_due_1y <", value, "nonCurLiabDue1y");
            return (Criteria) this;
        }

        public Criteria andNonCurLiabDue1yLessThanOrEqualTo(Float value) {
            addCriterion("non_cur_liab_due_1y <=", value, "nonCurLiabDue1y");
            return (Criteria) this;
        }

        public Criteria andNonCurLiabDue1yIn(List<Float> values) {
            addCriterion("non_cur_liab_due_1y in", values, "nonCurLiabDue1y");
            return (Criteria) this;
        }

        public Criteria andNonCurLiabDue1yNotIn(List<Float> values) {
            addCriterion("non_cur_liab_due_1y not in", values, "nonCurLiabDue1y");
            return (Criteria) this;
        }

        public Criteria andNonCurLiabDue1yBetween(Float value1, Float value2) {
            addCriterion("non_cur_liab_due_1y between", value1, value2, "nonCurLiabDue1y");
            return (Criteria) this;
        }

        public Criteria andNonCurLiabDue1yNotBetween(Float value1, Float value2) {
            addCriterion("non_cur_liab_due_1y not between", value1, value2, "nonCurLiabDue1y");
            return (Criteria) this;
        }

        public Criteria andOthCurLiabIsNull() {
            addCriterion("oth_cur_liab is null");
            return (Criteria) this;
        }

        public Criteria andOthCurLiabIsNotNull() {
            addCriterion("oth_cur_liab is not null");
            return (Criteria) this;
        }

        public Criteria andOthCurLiabEqualTo(Float value) {
            addCriterion("oth_cur_liab =", value, "othCurLiab");
            return (Criteria) this;
        }

        public Criteria andOthCurLiabNotEqualTo(Float value) {
            addCriterion("oth_cur_liab <>", value, "othCurLiab");
            return (Criteria) this;
        }

        public Criteria andOthCurLiabGreaterThan(Float value) {
            addCriterion("oth_cur_liab >", value, "othCurLiab");
            return (Criteria) this;
        }

        public Criteria andOthCurLiabGreaterThanOrEqualTo(Float value) {
            addCriterion("oth_cur_liab >=", value, "othCurLiab");
            return (Criteria) this;
        }

        public Criteria andOthCurLiabLessThan(Float value) {
            addCriterion("oth_cur_liab <", value, "othCurLiab");
            return (Criteria) this;
        }

        public Criteria andOthCurLiabLessThanOrEqualTo(Float value) {
            addCriterion("oth_cur_liab <=", value, "othCurLiab");
            return (Criteria) this;
        }

        public Criteria andOthCurLiabIn(List<Float> values) {
            addCriterion("oth_cur_liab in", values, "othCurLiab");
            return (Criteria) this;
        }

        public Criteria andOthCurLiabNotIn(List<Float> values) {
            addCriterion("oth_cur_liab not in", values, "othCurLiab");
            return (Criteria) this;
        }

        public Criteria andOthCurLiabBetween(Float value1, Float value2) {
            addCriterion("oth_cur_liab between", value1, value2, "othCurLiab");
            return (Criteria) this;
        }

        public Criteria andOthCurLiabNotBetween(Float value1, Float value2) {
            addCriterion("oth_cur_liab not between", value1, value2, "othCurLiab");
            return (Criteria) this;
        }

        public Criteria andTotalCurLiabIsNull() {
            addCriterion("total_cur_liab is null");
            return (Criteria) this;
        }

        public Criteria andTotalCurLiabIsNotNull() {
            addCriterion("total_cur_liab is not null");
            return (Criteria) this;
        }

        public Criteria andTotalCurLiabEqualTo(Float value) {
            addCriterion("total_cur_liab =", value, "totalCurLiab");
            return (Criteria) this;
        }

        public Criteria andTotalCurLiabNotEqualTo(Float value) {
            addCriterion("total_cur_liab <>", value, "totalCurLiab");
            return (Criteria) this;
        }

        public Criteria andTotalCurLiabGreaterThan(Float value) {
            addCriterion("total_cur_liab >", value, "totalCurLiab");
            return (Criteria) this;
        }

        public Criteria andTotalCurLiabGreaterThanOrEqualTo(Float value) {
            addCriterion("total_cur_liab >=", value, "totalCurLiab");
            return (Criteria) this;
        }

        public Criteria andTotalCurLiabLessThan(Float value) {
            addCriterion("total_cur_liab <", value, "totalCurLiab");
            return (Criteria) this;
        }

        public Criteria andTotalCurLiabLessThanOrEqualTo(Float value) {
            addCriterion("total_cur_liab <=", value, "totalCurLiab");
            return (Criteria) this;
        }

        public Criteria andTotalCurLiabIn(List<Float> values) {
            addCriterion("total_cur_liab in", values, "totalCurLiab");
            return (Criteria) this;
        }

        public Criteria andTotalCurLiabNotIn(List<Float> values) {
            addCriterion("total_cur_liab not in", values, "totalCurLiab");
            return (Criteria) this;
        }

        public Criteria andTotalCurLiabBetween(Float value1, Float value2) {
            addCriterion("total_cur_liab between", value1, value2, "totalCurLiab");
            return (Criteria) this;
        }

        public Criteria andTotalCurLiabNotBetween(Float value1, Float value2) {
            addCriterion("total_cur_liab not between", value1, value2, "totalCurLiab");
            return (Criteria) this;
        }

        public Criteria andBondPayableIsNull() {
            addCriterion("bond_payable is null");
            return (Criteria) this;
        }

        public Criteria andBondPayableIsNotNull() {
            addCriterion("bond_payable is not null");
            return (Criteria) this;
        }

        public Criteria andBondPayableEqualTo(Float value) {
            addCriterion("bond_payable =", value, "bondPayable");
            return (Criteria) this;
        }

        public Criteria andBondPayableNotEqualTo(Float value) {
            addCriterion("bond_payable <>", value, "bondPayable");
            return (Criteria) this;
        }

        public Criteria andBondPayableGreaterThan(Float value) {
            addCriterion("bond_payable >", value, "bondPayable");
            return (Criteria) this;
        }

        public Criteria andBondPayableGreaterThanOrEqualTo(Float value) {
            addCriterion("bond_payable >=", value, "bondPayable");
            return (Criteria) this;
        }

        public Criteria andBondPayableLessThan(Float value) {
            addCriterion("bond_payable <", value, "bondPayable");
            return (Criteria) this;
        }

        public Criteria andBondPayableLessThanOrEqualTo(Float value) {
            addCriterion("bond_payable <=", value, "bondPayable");
            return (Criteria) this;
        }

        public Criteria andBondPayableIn(List<Float> values) {
            addCriterion("bond_payable in", values, "bondPayable");
            return (Criteria) this;
        }

        public Criteria andBondPayableNotIn(List<Float> values) {
            addCriterion("bond_payable not in", values, "bondPayable");
            return (Criteria) this;
        }

        public Criteria andBondPayableBetween(Float value1, Float value2) {
            addCriterion("bond_payable between", value1, value2, "bondPayable");
            return (Criteria) this;
        }

        public Criteria andBondPayableNotBetween(Float value1, Float value2) {
            addCriterion("bond_payable not between", value1, value2, "bondPayable");
            return (Criteria) this;
        }

        public Criteria andLtPayableIsNull() {
            addCriterion("lt_payable is null");
            return (Criteria) this;
        }

        public Criteria andLtPayableIsNotNull() {
            addCriterion("lt_payable is not null");
            return (Criteria) this;
        }

        public Criteria andLtPayableEqualTo(Float value) {
            addCriterion("lt_payable =", value, "ltPayable");
            return (Criteria) this;
        }

        public Criteria andLtPayableNotEqualTo(Float value) {
            addCriterion("lt_payable <>", value, "ltPayable");
            return (Criteria) this;
        }

        public Criteria andLtPayableGreaterThan(Float value) {
            addCriterion("lt_payable >", value, "ltPayable");
            return (Criteria) this;
        }

        public Criteria andLtPayableGreaterThanOrEqualTo(Float value) {
            addCriterion("lt_payable >=", value, "ltPayable");
            return (Criteria) this;
        }

        public Criteria andLtPayableLessThan(Float value) {
            addCriterion("lt_payable <", value, "ltPayable");
            return (Criteria) this;
        }

        public Criteria andLtPayableLessThanOrEqualTo(Float value) {
            addCriterion("lt_payable <=", value, "ltPayable");
            return (Criteria) this;
        }

        public Criteria andLtPayableIn(List<Float> values) {
            addCriterion("lt_payable in", values, "ltPayable");
            return (Criteria) this;
        }

        public Criteria andLtPayableNotIn(List<Float> values) {
            addCriterion("lt_payable not in", values, "ltPayable");
            return (Criteria) this;
        }

        public Criteria andLtPayableBetween(Float value1, Float value2) {
            addCriterion("lt_payable between", value1, value2, "ltPayable");
            return (Criteria) this;
        }

        public Criteria andLtPayableNotBetween(Float value1, Float value2) {
            addCriterion("lt_payable not between", value1, value2, "ltPayable");
            return (Criteria) this;
        }

        public Criteria andSpecificPayablesIsNull() {
            addCriterion("specific_payables is null");
            return (Criteria) this;
        }

        public Criteria andSpecificPayablesIsNotNull() {
            addCriterion("specific_payables is not null");
            return (Criteria) this;
        }

        public Criteria andSpecificPayablesEqualTo(Float value) {
            addCriterion("specific_payables =", value, "specificPayables");
            return (Criteria) this;
        }

        public Criteria andSpecificPayablesNotEqualTo(Float value) {
            addCriterion("specific_payables <>", value, "specificPayables");
            return (Criteria) this;
        }

        public Criteria andSpecificPayablesGreaterThan(Float value) {
            addCriterion("specific_payables >", value, "specificPayables");
            return (Criteria) this;
        }

        public Criteria andSpecificPayablesGreaterThanOrEqualTo(Float value) {
            addCriterion("specific_payables >=", value, "specificPayables");
            return (Criteria) this;
        }

        public Criteria andSpecificPayablesLessThan(Float value) {
            addCriterion("specific_payables <", value, "specificPayables");
            return (Criteria) this;
        }

        public Criteria andSpecificPayablesLessThanOrEqualTo(Float value) {
            addCriterion("specific_payables <=", value, "specificPayables");
            return (Criteria) this;
        }

        public Criteria andSpecificPayablesIn(List<Float> values) {
            addCriterion("specific_payables in", values, "specificPayables");
            return (Criteria) this;
        }

        public Criteria andSpecificPayablesNotIn(List<Float> values) {
            addCriterion("specific_payables not in", values, "specificPayables");
            return (Criteria) this;
        }

        public Criteria andSpecificPayablesBetween(Float value1, Float value2) {
            addCriterion("specific_payables between", value1, value2, "specificPayables");
            return (Criteria) this;
        }

        public Criteria andSpecificPayablesNotBetween(Float value1, Float value2) {
            addCriterion("specific_payables not between", value1, value2, "specificPayables");
            return (Criteria) this;
        }

        public Criteria andEstimatedLiabIsNull() {
            addCriterion("estimated_liab is null");
            return (Criteria) this;
        }

        public Criteria andEstimatedLiabIsNotNull() {
            addCriterion("estimated_liab is not null");
            return (Criteria) this;
        }

        public Criteria andEstimatedLiabEqualTo(Float value) {
            addCriterion("estimated_liab =", value, "estimatedLiab");
            return (Criteria) this;
        }

        public Criteria andEstimatedLiabNotEqualTo(Float value) {
            addCriterion("estimated_liab <>", value, "estimatedLiab");
            return (Criteria) this;
        }

        public Criteria andEstimatedLiabGreaterThan(Float value) {
            addCriterion("estimated_liab >", value, "estimatedLiab");
            return (Criteria) this;
        }

        public Criteria andEstimatedLiabGreaterThanOrEqualTo(Float value) {
            addCriterion("estimated_liab >=", value, "estimatedLiab");
            return (Criteria) this;
        }

        public Criteria andEstimatedLiabLessThan(Float value) {
            addCriterion("estimated_liab <", value, "estimatedLiab");
            return (Criteria) this;
        }

        public Criteria andEstimatedLiabLessThanOrEqualTo(Float value) {
            addCriterion("estimated_liab <=", value, "estimatedLiab");
            return (Criteria) this;
        }

        public Criteria andEstimatedLiabIn(List<Float> values) {
            addCriterion("estimated_liab in", values, "estimatedLiab");
            return (Criteria) this;
        }

        public Criteria andEstimatedLiabNotIn(List<Float> values) {
            addCriterion("estimated_liab not in", values, "estimatedLiab");
            return (Criteria) this;
        }

        public Criteria andEstimatedLiabBetween(Float value1, Float value2) {
            addCriterion("estimated_liab between", value1, value2, "estimatedLiab");
            return (Criteria) this;
        }

        public Criteria andEstimatedLiabNotBetween(Float value1, Float value2) {
            addCriterion("estimated_liab not between", value1, value2, "estimatedLiab");
            return (Criteria) this;
        }

        public Criteria andDeferTaxLiabIsNull() {
            addCriterion("defer_tax_liab is null");
            return (Criteria) this;
        }

        public Criteria andDeferTaxLiabIsNotNull() {
            addCriterion("defer_tax_liab is not null");
            return (Criteria) this;
        }

        public Criteria andDeferTaxLiabEqualTo(Float value) {
            addCriterion("defer_tax_liab =", value, "deferTaxLiab");
            return (Criteria) this;
        }

        public Criteria andDeferTaxLiabNotEqualTo(Float value) {
            addCriterion("defer_tax_liab <>", value, "deferTaxLiab");
            return (Criteria) this;
        }

        public Criteria andDeferTaxLiabGreaterThan(Float value) {
            addCriterion("defer_tax_liab >", value, "deferTaxLiab");
            return (Criteria) this;
        }

        public Criteria andDeferTaxLiabGreaterThanOrEqualTo(Float value) {
            addCriterion("defer_tax_liab >=", value, "deferTaxLiab");
            return (Criteria) this;
        }

        public Criteria andDeferTaxLiabLessThan(Float value) {
            addCriterion("defer_tax_liab <", value, "deferTaxLiab");
            return (Criteria) this;
        }

        public Criteria andDeferTaxLiabLessThanOrEqualTo(Float value) {
            addCriterion("defer_tax_liab <=", value, "deferTaxLiab");
            return (Criteria) this;
        }

        public Criteria andDeferTaxLiabIn(List<Float> values) {
            addCriterion("defer_tax_liab in", values, "deferTaxLiab");
            return (Criteria) this;
        }

        public Criteria andDeferTaxLiabNotIn(List<Float> values) {
            addCriterion("defer_tax_liab not in", values, "deferTaxLiab");
            return (Criteria) this;
        }

        public Criteria andDeferTaxLiabBetween(Float value1, Float value2) {
            addCriterion("defer_tax_liab between", value1, value2, "deferTaxLiab");
            return (Criteria) this;
        }

        public Criteria andDeferTaxLiabNotBetween(Float value1, Float value2) {
            addCriterion("defer_tax_liab not between", value1, value2, "deferTaxLiab");
            return (Criteria) this;
        }

        public Criteria andDeferIncNonCurLiabIsNull() {
            addCriterion("defer_inc_non_cur_liab is null");
            return (Criteria) this;
        }

        public Criteria andDeferIncNonCurLiabIsNotNull() {
            addCriterion("defer_inc_non_cur_liab is not null");
            return (Criteria) this;
        }

        public Criteria andDeferIncNonCurLiabEqualTo(Float value) {
            addCriterion("defer_inc_non_cur_liab =", value, "deferIncNonCurLiab");
            return (Criteria) this;
        }

        public Criteria andDeferIncNonCurLiabNotEqualTo(Float value) {
            addCriterion("defer_inc_non_cur_liab <>", value, "deferIncNonCurLiab");
            return (Criteria) this;
        }

        public Criteria andDeferIncNonCurLiabGreaterThan(Float value) {
            addCriterion("defer_inc_non_cur_liab >", value, "deferIncNonCurLiab");
            return (Criteria) this;
        }

        public Criteria andDeferIncNonCurLiabGreaterThanOrEqualTo(Float value) {
            addCriterion("defer_inc_non_cur_liab >=", value, "deferIncNonCurLiab");
            return (Criteria) this;
        }

        public Criteria andDeferIncNonCurLiabLessThan(Float value) {
            addCriterion("defer_inc_non_cur_liab <", value, "deferIncNonCurLiab");
            return (Criteria) this;
        }

        public Criteria andDeferIncNonCurLiabLessThanOrEqualTo(Float value) {
            addCriterion("defer_inc_non_cur_liab <=", value, "deferIncNonCurLiab");
            return (Criteria) this;
        }

        public Criteria andDeferIncNonCurLiabIn(List<Float> values) {
            addCriterion("defer_inc_non_cur_liab in", values, "deferIncNonCurLiab");
            return (Criteria) this;
        }

        public Criteria andDeferIncNonCurLiabNotIn(List<Float> values) {
            addCriterion("defer_inc_non_cur_liab not in", values, "deferIncNonCurLiab");
            return (Criteria) this;
        }

        public Criteria andDeferIncNonCurLiabBetween(Float value1, Float value2) {
            addCriterion("defer_inc_non_cur_liab between", value1, value2, "deferIncNonCurLiab");
            return (Criteria) this;
        }

        public Criteria andDeferIncNonCurLiabNotBetween(Float value1, Float value2) {
            addCriterion("defer_inc_non_cur_liab not between", value1, value2, "deferIncNonCurLiab");
            return (Criteria) this;
        }

        public Criteria andOthNclIsNull() {
            addCriterion("oth_ncl is null");
            return (Criteria) this;
        }

        public Criteria andOthNclIsNotNull() {
            addCriterion("oth_ncl is not null");
            return (Criteria) this;
        }

        public Criteria andOthNclEqualTo(Float value) {
            addCriterion("oth_ncl =", value, "othNcl");
            return (Criteria) this;
        }

        public Criteria andOthNclNotEqualTo(Float value) {
            addCriterion("oth_ncl <>", value, "othNcl");
            return (Criteria) this;
        }

        public Criteria andOthNclGreaterThan(Float value) {
            addCriterion("oth_ncl >", value, "othNcl");
            return (Criteria) this;
        }

        public Criteria andOthNclGreaterThanOrEqualTo(Float value) {
            addCriterion("oth_ncl >=", value, "othNcl");
            return (Criteria) this;
        }

        public Criteria andOthNclLessThan(Float value) {
            addCriterion("oth_ncl <", value, "othNcl");
            return (Criteria) this;
        }

        public Criteria andOthNclLessThanOrEqualTo(Float value) {
            addCriterion("oth_ncl <=", value, "othNcl");
            return (Criteria) this;
        }

        public Criteria andOthNclIn(List<Float> values) {
            addCriterion("oth_ncl in", values, "othNcl");
            return (Criteria) this;
        }

        public Criteria andOthNclNotIn(List<Float> values) {
            addCriterion("oth_ncl not in", values, "othNcl");
            return (Criteria) this;
        }

        public Criteria andOthNclBetween(Float value1, Float value2) {
            addCriterion("oth_ncl between", value1, value2, "othNcl");
            return (Criteria) this;
        }

        public Criteria andOthNclNotBetween(Float value1, Float value2) {
            addCriterion("oth_ncl not between", value1, value2, "othNcl");
            return (Criteria) this;
        }

        public Criteria andTotalNclIsNull() {
            addCriterion("total_ncl is null");
            return (Criteria) this;
        }

        public Criteria andTotalNclIsNotNull() {
            addCriterion("total_ncl is not null");
            return (Criteria) this;
        }

        public Criteria andTotalNclEqualTo(Float value) {
            addCriterion("total_ncl =", value, "totalNcl");
            return (Criteria) this;
        }

        public Criteria andTotalNclNotEqualTo(Float value) {
            addCriterion("total_ncl <>", value, "totalNcl");
            return (Criteria) this;
        }

        public Criteria andTotalNclGreaterThan(Float value) {
            addCriterion("total_ncl >", value, "totalNcl");
            return (Criteria) this;
        }

        public Criteria andTotalNclGreaterThanOrEqualTo(Float value) {
            addCriterion("total_ncl >=", value, "totalNcl");
            return (Criteria) this;
        }

        public Criteria andTotalNclLessThan(Float value) {
            addCriterion("total_ncl <", value, "totalNcl");
            return (Criteria) this;
        }

        public Criteria andTotalNclLessThanOrEqualTo(Float value) {
            addCriterion("total_ncl <=", value, "totalNcl");
            return (Criteria) this;
        }

        public Criteria andTotalNclIn(List<Float> values) {
            addCriterion("total_ncl in", values, "totalNcl");
            return (Criteria) this;
        }

        public Criteria andTotalNclNotIn(List<Float> values) {
            addCriterion("total_ncl not in", values, "totalNcl");
            return (Criteria) this;
        }

        public Criteria andTotalNclBetween(Float value1, Float value2) {
            addCriterion("total_ncl between", value1, value2, "totalNcl");
            return (Criteria) this;
        }

        public Criteria andTotalNclNotBetween(Float value1, Float value2) {
            addCriterion("total_ncl not between", value1, value2, "totalNcl");
            return (Criteria) this;
        }

        public Criteria andDeposOthBfiIsNull() {
            addCriterion("depos_oth_bfi is null");
            return (Criteria) this;
        }

        public Criteria andDeposOthBfiIsNotNull() {
            addCriterion("depos_oth_bfi is not null");
            return (Criteria) this;
        }

        public Criteria andDeposOthBfiEqualTo(Float value) {
            addCriterion("depos_oth_bfi =", value, "deposOthBfi");
            return (Criteria) this;
        }

        public Criteria andDeposOthBfiNotEqualTo(Float value) {
            addCriterion("depos_oth_bfi <>", value, "deposOthBfi");
            return (Criteria) this;
        }

        public Criteria andDeposOthBfiGreaterThan(Float value) {
            addCriterion("depos_oth_bfi >", value, "deposOthBfi");
            return (Criteria) this;
        }

        public Criteria andDeposOthBfiGreaterThanOrEqualTo(Float value) {
            addCriterion("depos_oth_bfi >=", value, "deposOthBfi");
            return (Criteria) this;
        }

        public Criteria andDeposOthBfiLessThan(Float value) {
            addCriterion("depos_oth_bfi <", value, "deposOthBfi");
            return (Criteria) this;
        }

        public Criteria andDeposOthBfiLessThanOrEqualTo(Float value) {
            addCriterion("depos_oth_bfi <=", value, "deposOthBfi");
            return (Criteria) this;
        }

        public Criteria andDeposOthBfiIn(List<Float> values) {
            addCriterion("depos_oth_bfi in", values, "deposOthBfi");
            return (Criteria) this;
        }

        public Criteria andDeposOthBfiNotIn(List<Float> values) {
            addCriterion("depos_oth_bfi not in", values, "deposOthBfi");
            return (Criteria) this;
        }

        public Criteria andDeposOthBfiBetween(Float value1, Float value2) {
            addCriterion("depos_oth_bfi between", value1, value2, "deposOthBfi");
            return (Criteria) this;
        }

        public Criteria andDeposOthBfiNotBetween(Float value1, Float value2) {
            addCriterion("depos_oth_bfi not between", value1, value2, "deposOthBfi");
            return (Criteria) this;
        }

        public Criteria andDerivLiabIsNull() {
            addCriterion("deriv_liab is null");
            return (Criteria) this;
        }

        public Criteria andDerivLiabIsNotNull() {
            addCriterion("deriv_liab is not null");
            return (Criteria) this;
        }

        public Criteria andDerivLiabEqualTo(Float value) {
            addCriterion("deriv_liab =", value, "derivLiab");
            return (Criteria) this;
        }

        public Criteria andDerivLiabNotEqualTo(Float value) {
            addCriterion("deriv_liab <>", value, "derivLiab");
            return (Criteria) this;
        }

        public Criteria andDerivLiabGreaterThan(Float value) {
            addCriterion("deriv_liab >", value, "derivLiab");
            return (Criteria) this;
        }

        public Criteria andDerivLiabGreaterThanOrEqualTo(Float value) {
            addCriterion("deriv_liab >=", value, "derivLiab");
            return (Criteria) this;
        }

        public Criteria andDerivLiabLessThan(Float value) {
            addCriterion("deriv_liab <", value, "derivLiab");
            return (Criteria) this;
        }

        public Criteria andDerivLiabLessThanOrEqualTo(Float value) {
            addCriterion("deriv_liab <=", value, "derivLiab");
            return (Criteria) this;
        }

        public Criteria andDerivLiabIn(List<Float> values) {
            addCriterion("deriv_liab in", values, "derivLiab");
            return (Criteria) this;
        }

        public Criteria andDerivLiabNotIn(List<Float> values) {
            addCriterion("deriv_liab not in", values, "derivLiab");
            return (Criteria) this;
        }

        public Criteria andDerivLiabBetween(Float value1, Float value2) {
            addCriterion("deriv_liab between", value1, value2, "derivLiab");
            return (Criteria) this;
        }

        public Criteria andDerivLiabNotBetween(Float value1, Float value2) {
            addCriterion("deriv_liab not between", value1, value2, "derivLiab");
            return (Criteria) this;
        }

        public Criteria andDeposIsNull() {
            addCriterion("depos is null");
            return (Criteria) this;
        }

        public Criteria andDeposIsNotNull() {
            addCriterion("depos is not null");
            return (Criteria) this;
        }

        public Criteria andDeposEqualTo(Float value) {
            addCriterion("depos =", value, "depos");
            return (Criteria) this;
        }

        public Criteria andDeposNotEqualTo(Float value) {
            addCriterion("depos <>", value, "depos");
            return (Criteria) this;
        }

        public Criteria andDeposGreaterThan(Float value) {
            addCriterion("depos >", value, "depos");
            return (Criteria) this;
        }

        public Criteria andDeposGreaterThanOrEqualTo(Float value) {
            addCriterion("depos >=", value, "depos");
            return (Criteria) this;
        }

        public Criteria andDeposLessThan(Float value) {
            addCriterion("depos <", value, "depos");
            return (Criteria) this;
        }

        public Criteria andDeposLessThanOrEqualTo(Float value) {
            addCriterion("depos <=", value, "depos");
            return (Criteria) this;
        }

        public Criteria andDeposIn(List<Float> values) {
            addCriterion("depos in", values, "depos");
            return (Criteria) this;
        }

        public Criteria andDeposNotIn(List<Float> values) {
            addCriterion("depos not in", values, "depos");
            return (Criteria) this;
        }

        public Criteria andDeposBetween(Float value1, Float value2) {
            addCriterion("depos between", value1, value2, "depos");
            return (Criteria) this;
        }

        public Criteria andDeposNotBetween(Float value1, Float value2) {
            addCriterion("depos not between", value1, value2, "depos");
            return (Criteria) this;
        }

        public Criteria andAgencyBusLiabIsNull() {
            addCriterion("agency_bus_liab is null");
            return (Criteria) this;
        }

        public Criteria andAgencyBusLiabIsNotNull() {
            addCriterion("agency_bus_liab is not null");
            return (Criteria) this;
        }

        public Criteria andAgencyBusLiabEqualTo(Float value) {
            addCriterion("agency_bus_liab =", value, "agencyBusLiab");
            return (Criteria) this;
        }

        public Criteria andAgencyBusLiabNotEqualTo(Float value) {
            addCriterion("agency_bus_liab <>", value, "agencyBusLiab");
            return (Criteria) this;
        }

        public Criteria andAgencyBusLiabGreaterThan(Float value) {
            addCriterion("agency_bus_liab >", value, "agencyBusLiab");
            return (Criteria) this;
        }

        public Criteria andAgencyBusLiabGreaterThanOrEqualTo(Float value) {
            addCriterion("agency_bus_liab >=", value, "agencyBusLiab");
            return (Criteria) this;
        }

        public Criteria andAgencyBusLiabLessThan(Float value) {
            addCriterion("agency_bus_liab <", value, "agencyBusLiab");
            return (Criteria) this;
        }

        public Criteria andAgencyBusLiabLessThanOrEqualTo(Float value) {
            addCriterion("agency_bus_liab <=", value, "agencyBusLiab");
            return (Criteria) this;
        }

        public Criteria andAgencyBusLiabIn(List<Float> values) {
            addCriterion("agency_bus_liab in", values, "agencyBusLiab");
            return (Criteria) this;
        }

        public Criteria andAgencyBusLiabNotIn(List<Float> values) {
            addCriterion("agency_bus_liab not in", values, "agencyBusLiab");
            return (Criteria) this;
        }

        public Criteria andAgencyBusLiabBetween(Float value1, Float value2) {
            addCriterion("agency_bus_liab between", value1, value2, "agencyBusLiab");
            return (Criteria) this;
        }

        public Criteria andAgencyBusLiabNotBetween(Float value1, Float value2) {
            addCriterion("agency_bus_liab not between", value1, value2, "agencyBusLiab");
            return (Criteria) this;
        }

        public Criteria andOthLiabIsNull() {
            addCriterion("oth_liab is null");
            return (Criteria) this;
        }

        public Criteria andOthLiabIsNotNull() {
            addCriterion("oth_liab is not null");
            return (Criteria) this;
        }

        public Criteria andOthLiabEqualTo(Float value) {
            addCriterion("oth_liab =", value, "othLiab");
            return (Criteria) this;
        }

        public Criteria andOthLiabNotEqualTo(Float value) {
            addCriterion("oth_liab <>", value, "othLiab");
            return (Criteria) this;
        }

        public Criteria andOthLiabGreaterThan(Float value) {
            addCriterion("oth_liab >", value, "othLiab");
            return (Criteria) this;
        }

        public Criteria andOthLiabGreaterThanOrEqualTo(Float value) {
            addCriterion("oth_liab >=", value, "othLiab");
            return (Criteria) this;
        }

        public Criteria andOthLiabLessThan(Float value) {
            addCriterion("oth_liab <", value, "othLiab");
            return (Criteria) this;
        }

        public Criteria andOthLiabLessThanOrEqualTo(Float value) {
            addCriterion("oth_liab <=", value, "othLiab");
            return (Criteria) this;
        }

        public Criteria andOthLiabIn(List<Float> values) {
            addCriterion("oth_liab in", values, "othLiab");
            return (Criteria) this;
        }

        public Criteria andOthLiabNotIn(List<Float> values) {
            addCriterion("oth_liab not in", values, "othLiab");
            return (Criteria) this;
        }

        public Criteria andOthLiabBetween(Float value1, Float value2) {
            addCriterion("oth_liab between", value1, value2, "othLiab");
            return (Criteria) this;
        }

        public Criteria andOthLiabNotBetween(Float value1, Float value2) {
            addCriterion("oth_liab not between", value1, value2, "othLiab");
            return (Criteria) this;
        }

        public Criteria andPremReceivAdvaIsNull() {
            addCriterion("prem_receiv_adva is null");
            return (Criteria) this;
        }

        public Criteria andPremReceivAdvaIsNotNull() {
            addCriterion("prem_receiv_adva is not null");
            return (Criteria) this;
        }

        public Criteria andPremReceivAdvaEqualTo(Float value) {
            addCriterion("prem_receiv_adva =", value, "premReceivAdva");
            return (Criteria) this;
        }

        public Criteria andPremReceivAdvaNotEqualTo(Float value) {
            addCriterion("prem_receiv_adva <>", value, "premReceivAdva");
            return (Criteria) this;
        }

        public Criteria andPremReceivAdvaGreaterThan(Float value) {
            addCriterion("prem_receiv_adva >", value, "premReceivAdva");
            return (Criteria) this;
        }

        public Criteria andPremReceivAdvaGreaterThanOrEqualTo(Float value) {
            addCriterion("prem_receiv_adva >=", value, "premReceivAdva");
            return (Criteria) this;
        }

        public Criteria andPremReceivAdvaLessThan(Float value) {
            addCriterion("prem_receiv_adva <", value, "premReceivAdva");
            return (Criteria) this;
        }

        public Criteria andPremReceivAdvaLessThanOrEqualTo(Float value) {
            addCriterion("prem_receiv_adva <=", value, "premReceivAdva");
            return (Criteria) this;
        }

        public Criteria andPremReceivAdvaIn(List<Float> values) {
            addCriterion("prem_receiv_adva in", values, "premReceivAdva");
            return (Criteria) this;
        }

        public Criteria andPremReceivAdvaNotIn(List<Float> values) {
            addCriterion("prem_receiv_adva not in", values, "premReceivAdva");
            return (Criteria) this;
        }

        public Criteria andPremReceivAdvaBetween(Float value1, Float value2) {
            addCriterion("prem_receiv_adva between", value1, value2, "premReceivAdva");
            return (Criteria) this;
        }

        public Criteria andPremReceivAdvaNotBetween(Float value1, Float value2) {
            addCriterion("prem_receiv_adva not between", value1, value2, "premReceivAdva");
            return (Criteria) this;
        }

        public Criteria andDeposReceivedIsNull() {
            addCriterion("depos_received is null");
            return (Criteria) this;
        }

        public Criteria andDeposReceivedIsNotNull() {
            addCriterion("depos_received is not null");
            return (Criteria) this;
        }

        public Criteria andDeposReceivedEqualTo(Float value) {
            addCriterion("depos_received =", value, "deposReceived");
            return (Criteria) this;
        }

        public Criteria andDeposReceivedNotEqualTo(Float value) {
            addCriterion("depos_received <>", value, "deposReceived");
            return (Criteria) this;
        }

        public Criteria andDeposReceivedGreaterThan(Float value) {
            addCriterion("depos_received >", value, "deposReceived");
            return (Criteria) this;
        }

        public Criteria andDeposReceivedGreaterThanOrEqualTo(Float value) {
            addCriterion("depos_received >=", value, "deposReceived");
            return (Criteria) this;
        }

        public Criteria andDeposReceivedLessThan(Float value) {
            addCriterion("depos_received <", value, "deposReceived");
            return (Criteria) this;
        }

        public Criteria andDeposReceivedLessThanOrEqualTo(Float value) {
            addCriterion("depos_received <=", value, "deposReceived");
            return (Criteria) this;
        }

        public Criteria andDeposReceivedIn(List<Float> values) {
            addCriterion("depos_received in", values, "deposReceived");
            return (Criteria) this;
        }

        public Criteria andDeposReceivedNotIn(List<Float> values) {
            addCriterion("depos_received not in", values, "deposReceived");
            return (Criteria) this;
        }

        public Criteria andDeposReceivedBetween(Float value1, Float value2) {
            addCriterion("depos_received between", value1, value2, "deposReceived");
            return (Criteria) this;
        }

        public Criteria andDeposReceivedNotBetween(Float value1, Float value2) {
            addCriterion("depos_received not between", value1, value2, "deposReceived");
            return (Criteria) this;
        }

        public Criteria andPhInvestIsNull() {
            addCriterion("ph_invest is null");
            return (Criteria) this;
        }

        public Criteria andPhInvestIsNotNull() {
            addCriterion("ph_invest is not null");
            return (Criteria) this;
        }

        public Criteria andPhInvestEqualTo(Float value) {
            addCriterion("ph_invest =", value, "phInvest");
            return (Criteria) this;
        }

        public Criteria andPhInvestNotEqualTo(Float value) {
            addCriterion("ph_invest <>", value, "phInvest");
            return (Criteria) this;
        }

        public Criteria andPhInvestGreaterThan(Float value) {
            addCriterion("ph_invest >", value, "phInvest");
            return (Criteria) this;
        }

        public Criteria andPhInvestGreaterThanOrEqualTo(Float value) {
            addCriterion("ph_invest >=", value, "phInvest");
            return (Criteria) this;
        }

        public Criteria andPhInvestLessThan(Float value) {
            addCriterion("ph_invest <", value, "phInvest");
            return (Criteria) this;
        }

        public Criteria andPhInvestLessThanOrEqualTo(Float value) {
            addCriterion("ph_invest <=", value, "phInvest");
            return (Criteria) this;
        }

        public Criteria andPhInvestIn(List<Float> values) {
            addCriterion("ph_invest in", values, "phInvest");
            return (Criteria) this;
        }

        public Criteria andPhInvestNotIn(List<Float> values) {
            addCriterion("ph_invest not in", values, "phInvest");
            return (Criteria) this;
        }

        public Criteria andPhInvestBetween(Float value1, Float value2) {
            addCriterion("ph_invest between", value1, value2, "phInvest");
            return (Criteria) this;
        }

        public Criteria andPhInvestNotBetween(Float value1, Float value2) {
            addCriterion("ph_invest not between", value1, value2, "phInvest");
            return (Criteria) this;
        }

        public Criteria andReserUnePremIsNull() {
            addCriterion("reser_une_prem is null");
            return (Criteria) this;
        }

        public Criteria andReserUnePremIsNotNull() {
            addCriterion("reser_une_prem is not null");
            return (Criteria) this;
        }

        public Criteria andReserUnePremEqualTo(Float value) {
            addCriterion("reser_une_prem =", value, "reserUnePrem");
            return (Criteria) this;
        }

        public Criteria andReserUnePremNotEqualTo(Float value) {
            addCriterion("reser_une_prem <>", value, "reserUnePrem");
            return (Criteria) this;
        }

        public Criteria andReserUnePremGreaterThan(Float value) {
            addCriterion("reser_une_prem >", value, "reserUnePrem");
            return (Criteria) this;
        }

        public Criteria andReserUnePremGreaterThanOrEqualTo(Float value) {
            addCriterion("reser_une_prem >=", value, "reserUnePrem");
            return (Criteria) this;
        }

        public Criteria andReserUnePremLessThan(Float value) {
            addCriterion("reser_une_prem <", value, "reserUnePrem");
            return (Criteria) this;
        }

        public Criteria andReserUnePremLessThanOrEqualTo(Float value) {
            addCriterion("reser_une_prem <=", value, "reserUnePrem");
            return (Criteria) this;
        }

        public Criteria andReserUnePremIn(List<Float> values) {
            addCriterion("reser_une_prem in", values, "reserUnePrem");
            return (Criteria) this;
        }

        public Criteria andReserUnePremNotIn(List<Float> values) {
            addCriterion("reser_une_prem not in", values, "reserUnePrem");
            return (Criteria) this;
        }

        public Criteria andReserUnePremBetween(Float value1, Float value2) {
            addCriterion("reser_une_prem between", value1, value2, "reserUnePrem");
            return (Criteria) this;
        }

        public Criteria andReserUnePremNotBetween(Float value1, Float value2) {
            addCriterion("reser_une_prem not between", value1, value2, "reserUnePrem");
            return (Criteria) this;
        }

        public Criteria andReserOutstdClaimsIsNull() {
            addCriterion("reser_outstd_claims is null");
            return (Criteria) this;
        }

        public Criteria andReserOutstdClaimsIsNotNull() {
            addCriterion("reser_outstd_claims is not null");
            return (Criteria) this;
        }

        public Criteria andReserOutstdClaimsEqualTo(Float value) {
            addCriterion("reser_outstd_claims =", value, "reserOutstdClaims");
            return (Criteria) this;
        }

        public Criteria andReserOutstdClaimsNotEqualTo(Float value) {
            addCriterion("reser_outstd_claims <>", value, "reserOutstdClaims");
            return (Criteria) this;
        }

        public Criteria andReserOutstdClaimsGreaterThan(Float value) {
            addCriterion("reser_outstd_claims >", value, "reserOutstdClaims");
            return (Criteria) this;
        }

        public Criteria andReserOutstdClaimsGreaterThanOrEqualTo(Float value) {
            addCriterion("reser_outstd_claims >=", value, "reserOutstdClaims");
            return (Criteria) this;
        }

        public Criteria andReserOutstdClaimsLessThan(Float value) {
            addCriterion("reser_outstd_claims <", value, "reserOutstdClaims");
            return (Criteria) this;
        }

        public Criteria andReserOutstdClaimsLessThanOrEqualTo(Float value) {
            addCriterion("reser_outstd_claims <=", value, "reserOutstdClaims");
            return (Criteria) this;
        }

        public Criteria andReserOutstdClaimsIn(List<Float> values) {
            addCriterion("reser_outstd_claims in", values, "reserOutstdClaims");
            return (Criteria) this;
        }

        public Criteria andReserOutstdClaimsNotIn(List<Float> values) {
            addCriterion("reser_outstd_claims not in", values, "reserOutstdClaims");
            return (Criteria) this;
        }

        public Criteria andReserOutstdClaimsBetween(Float value1, Float value2) {
            addCriterion("reser_outstd_claims between", value1, value2, "reserOutstdClaims");
            return (Criteria) this;
        }

        public Criteria andReserOutstdClaimsNotBetween(Float value1, Float value2) {
            addCriterion("reser_outstd_claims not between", value1, value2, "reserOutstdClaims");
            return (Criteria) this;
        }

        public Criteria andReserLinsLiabIsNull() {
            addCriterion("reser_lins_liab is null");
            return (Criteria) this;
        }

        public Criteria andReserLinsLiabIsNotNull() {
            addCriterion("reser_lins_liab is not null");
            return (Criteria) this;
        }

        public Criteria andReserLinsLiabEqualTo(Float value) {
            addCriterion("reser_lins_liab =", value, "reserLinsLiab");
            return (Criteria) this;
        }

        public Criteria andReserLinsLiabNotEqualTo(Float value) {
            addCriterion("reser_lins_liab <>", value, "reserLinsLiab");
            return (Criteria) this;
        }

        public Criteria andReserLinsLiabGreaterThan(Float value) {
            addCriterion("reser_lins_liab >", value, "reserLinsLiab");
            return (Criteria) this;
        }

        public Criteria andReserLinsLiabGreaterThanOrEqualTo(Float value) {
            addCriterion("reser_lins_liab >=", value, "reserLinsLiab");
            return (Criteria) this;
        }

        public Criteria andReserLinsLiabLessThan(Float value) {
            addCriterion("reser_lins_liab <", value, "reserLinsLiab");
            return (Criteria) this;
        }

        public Criteria andReserLinsLiabLessThanOrEqualTo(Float value) {
            addCriterion("reser_lins_liab <=", value, "reserLinsLiab");
            return (Criteria) this;
        }

        public Criteria andReserLinsLiabIn(List<Float> values) {
            addCriterion("reser_lins_liab in", values, "reserLinsLiab");
            return (Criteria) this;
        }

        public Criteria andReserLinsLiabNotIn(List<Float> values) {
            addCriterion("reser_lins_liab not in", values, "reserLinsLiab");
            return (Criteria) this;
        }

        public Criteria andReserLinsLiabBetween(Float value1, Float value2) {
            addCriterion("reser_lins_liab between", value1, value2, "reserLinsLiab");
            return (Criteria) this;
        }

        public Criteria andReserLinsLiabNotBetween(Float value1, Float value2) {
            addCriterion("reser_lins_liab not between", value1, value2, "reserLinsLiab");
            return (Criteria) this;
        }

        public Criteria andReserLthinsLiabIsNull() {
            addCriterion("reser_lthins_liab is null");
            return (Criteria) this;
        }

        public Criteria andReserLthinsLiabIsNotNull() {
            addCriterion("reser_lthins_liab is not null");
            return (Criteria) this;
        }

        public Criteria andReserLthinsLiabEqualTo(Float value) {
            addCriterion("reser_lthins_liab =", value, "reserLthinsLiab");
            return (Criteria) this;
        }

        public Criteria andReserLthinsLiabNotEqualTo(Float value) {
            addCriterion("reser_lthins_liab <>", value, "reserLthinsLiab");
            return (Criteria) this;
        }

        public Criteria andReserLthinsLiabGreaterThan(Float value) {
            addCriterion("reser_lthins_liab >", value, "reserLthinsLiab");
            return (Criteria) this;
        }

        public Criteria andReserLthinsLiabGreaterThanOrEqualTo(Float value) {
            addCriterion("reser_lthins_liab >=", value, "reserLthinsLiab");
            return (Criteria) this;
        }

        public Criteria andReserLthinsLiabLessThan(Float value) {
            addCriterion("reser_lthins_liab <", value, "reserLthinsLiab");
            return (Criteria) this;
        }

        public Criteria andReserLthinsLiabLessThanOrEqualTo(Float value) {
            addCriterion("reser_lthins_liab <=", value, "reserLthinsLiab");
            return (Criteria) this;
        }

        public Criteria andReserLthinsLiabIn(List<Float> values) {
            addCriterion("reser_lthins_liab in", values, "reserLthinsLiab");
            return (Criteria) this;
        }

        public Criteria andReserLthinsLiabNotIn(List<Float> values) {
            addCriterion("reser_lthins_liab not in", values, "reserLthinsLiab");
            return (Criteria) this;
        }

        public Criteria andReserLthinsLiabBetween(Float value1, Float value2) {
            addCriterion("reser_lthins_liab between", value1, value2, "reserLthinsLiab");
            return (Criteria) this;
        }

        public Criteria andReserLthinsLiabNotBetween(Float value1, Float value2) {
            addCriterion("reser_lthins_liab not between", value1, value2, "reserLthinsLiab");
            return (Criteria) this;
        }

        public Criteria andIndeptAccLiabIsNull() {
            addCriterion("indept_acc_liab is null");
            return (Criteria) this;
        }

        public Criteria andIndeptAccLiabIsNotNull() {
            addCriterion("indept_acc_liab is not null");
            return (Criteria) this;
        }

        public Criteria andIndeptAccLiabEqualTo(Float value) {
            addCriterion("indept_acc_liab =", value, "indeptAccLiab");
            return (Criteria) this;
        }

        public Criteria andIndeptAccLiabNotEqualTo(Float value) {
            addCriterion("indept_acc_liab <>", value, "indeptAccLiab");
            return (Criteria) this;
        }

        public Criteria andIndeptAccLiabGreaterThan(Float value) {
            addCriterion("indept_acc_liab >", value, "indeptAccLiab");
            return (Criteria) this;
        }

        public Criteria andIndeptAccLiabGreaterThanOrEqualTo(Float value) {
            addCriterion("indept_acc_liab >=", value, "indeptAccLiab");
            return (Criteria) this;
        }

        public Criteria andIndeptAccLiabLessThan(Float value) {
            addCriterion("indept_acc_liab <", value, "indeptAccLiab");
            return (Criteria) this;
        }

        public Criteria andIndeptAccLiabLessThanOrEqualTo(Float value) {
            addCriterion("indept_acc_liab <=", value, "indeptAccLiab");
            return (Criteria) this;
        }

        public Criteria andIndeptAccLiabIn(List<Float> values) {
            addCriterion("indept_acc_liab in", values, "indeptAccLiab");
            return (Criteria) this;
        }

        public Criteria andIndeptAccLiabNotIn(List<Float> values) {
            addCriterion("indept_acc_liab not in", values, "indeptAccLiab");
            return (Criteria) this;
        }

        public Criteria andIndeptAccLiabBetween(Float value1, Float value2) {
            addCriterion("indept_acc_liab between", value1, value2, "indeptAccLiab");
            return (Criteria) this;
        }

        public Criteria andIndeptAccLiabNotBetween(Float value1, Float value2) {
            addCriterion("indept_acc_liab not between", value1, value2, "indeptAccLiab");
            return (Criteria) this;
        }

        public Criteria andPledgeBorrIsNull() {
            addCriterion("pledge_borr is null");
            return (Criteria) this;
        }

        public Criteria andPledgeBorrIsNotNull() {
            addCriterion("pledge_borr is not null");
            return (Criteria) this;
        }

        public Criteria andPledgeBorrEqualTo(Float value) {
            addCriterion("pledge_borr =", value, "pledgeBorr");
            return (Criteria) this;
        }

        public Criteria andPledgeBorrNotEqualTo(Float value) {
            addCriterion("pledge_borr <>", value, "pledgeBorr");
            return (Criteria) this;
        }

        public Criteria andPledgeBorrGreaterThan(Float value) {
            addCriterion("pledge_borr >", value, "pledgeBorr");
            return (Criteria) this;
        }

        public Criteria andPledgeBorrGreaterThanOrEqualTo(Float value) {
            addCriterion("pledge_borr >=", value, "pledgeBorr");
            return (Criteria) this;
        }

        public Criteria andPledgeBorrLessThan(Float value) {
            addCriterion("pledge_borr <", value, "pledgeBorr");
            return (Criteria) this;
        }

        public Criteria andPledgeBorrLessThanOrEqualTo(Float value) {
            addCriterion("pledge_borr <=", value, "pledgeBorr");
            return (Criteria) this;
        }

        public Criteria andPledgeBorrIn(List<Float> values) {
            addCriterion("pledge_borr in", values, "pledgeBorr");
            return (Criteria) this;
        }

        public Criteria andPledgeBorrNotIn(List<Float> values) {
            addCriterion("pledge_borr not in", values, "pledgeBorr");
            return (Criteria) this;
        }

        public Criteria andPledgeBorrBetween(Float value1, Float value2) {
            addCriterion("pledge_borr between", value1, value2, "pledgeBorr");
            return (Criteria) this;
        }

        public Criteria andPledgeBorrNotBetween(Float value1, Float value2) {
            addCriterion("pledge_borr not between", value1, value2, "pledgeBorr");
            return (Criteria) this;
        }

        public Criteria andIndemPayableIsNull() {
            addCriterion("indem_payable is null");
            return (Criteria) this;
        }

        public Criteria andIndemPayableIsNotNull() {
            addCriterion("indem_payable is not null");
            return (Criteria) this;
        }

        public Criteria andIndemPayableEqualTo(Float value) {
            addCriterion("indem_payable =", value, "indemPayable");
            return (Criteria) this;
        }

        public Criteria andIndemPayableNotEqualTo(Float value) {
            addCriterion("indem_payable <>", value, "indemPayable");
            return (Criteria) this;
        }

        public Criteria andIndemPayableGreaterThan(Float value) {
            addCriterion("indem_payable >", value, "indemPayable");
            return (Criteria) this;
        }

        public Criteria andIndemPayableGreaterThanOrEqualTo(Float value) {
            addCriterion("indem_payable >=", value, "indemPayable");
            return (Criteria) this;
        }

        public Criteria andIndemPayableLessThan(Float value) {
            addCriterion("indem_payable <", value, "indemPayable");
            return (Criteria) this;
        }

        public Criteria andIndemPayableLessThanOrEqualTo(Float value) {
            addCriterion("indem_payable <=", value, "indemPayable");
            return (Criteria) this;
        }

        public Criteria andIndemPayableIn(List<Float> values) {
            addCriterion("indem_payable in", values, "indemPayable");
            return (Criteria) this;
        }

        public Criteria andIndemPayableNotIn(List<Float> values) {
            addCriterion("indem_payable not in", values, "indemPayable");
            return (Criteria) this;
        }

        public Criteria andIndemPayableBetween(Float value1, Float value2) {
            addCriterion("indem_payable between", value1, value2, "indemPayable");
            return (Criteria) this;
        }

        public Criteria andIndemPayableNotBetween(Float value1, Float value2) {
            addCriterion("indem_payable not between", value1, value2, "indemPayable");
            return (Criteria) this;
        }

        public Criteria andPolicyDivPayableIsNull() {
            addCriterion("policy_div_payable is null");
            return (Criteria) this;
        }

        public Criteria andPolicyDivPayableIsNotNull() {
            addCriterion("policy_div_payable is not null");
            return (Criteria) this;
        }

        public Criteria andPolicyDivPayableEqualTo(Float value) {
            addCriterion("policy_div_payable =", value, "policyDivPayable");
            return (Criteria) this;
        }

        public Criteria andPolicyDivPayableNotEqualTo(Float value) {
            addCriterion("policy_div_payable <>", value, "policyDivPayable");
            return (Criteria) this;
        }

        public Criteria andPolicyDivPayableGreaterThan(Float value) {
            addCriterion("policy_div_payable >", value, "policyDivPayable");
            return (Criteria) this;
        }

        public Criteria andPolicyDivPayableGreaterThanOrEqualTo(Float value) {
            addCriterion("policy_div_payable >=", value, "policyDivPayable");
            return (Criteria) this;
        }

        public Criteria andPolicyDivPayableLessThan(Float value) {
            addCriterion("policy_div_payable <", value, "policyDivPayable");
            return (Criteria) this;
        }

        public Criteria andPolicyDivPayableLessThanOrEqualTo(Float value) {
            addCriterion("policy_div_payable <=", value, "policyDivPayable");
            return (Criteria) this;
        }

        public Criteria andPolicyDivPayableIn(List<Float> values) {
            addCriterion("policy_div_payable in", values, "policyDivPayable");
            return (Criteria) this;
        }

        public Criteria andPolicyDivPayableNotIn(List<Float> values) {
            addCriterion("policy_div_payable not in", values, "policyDivPayable");
            return (Criteria) this;
        }

        public Criteria andPolicyDivPayableBetween(Float value1, Float value2) {
            addCriterion("policy_div_payable between", value1, value2, "policyDivPayable");
            return (Criteria) this;
        }

        public Criteria andPolicyDivPayableNotBetween(Float value1, Float value2) {
            addCriterion("policy_div_payable not between", value1, value2, "policyDivPayable");
            return (Criteria) this;
        }

        public Criteria andTotalLiabIsNull() {
            addCriterion("total_liab is null");
            return (Criteria) this;
        }

        public Criteria andTotalLiabIsNotNull() {
            addCriterion("total_liab is not null");
            return (Criteria) this;
        }

        public Criteria andTotalLiabEqualTo(Float value) {
            addCriterion("total_liab =", value, "totalLiab");
            return (Criteria) this;
        }

        public Criteria andTotalLiabNotEqualTo(Float value) {
            addCriterion("total_liab <>", value, "totalLiab");
            return (Criteria) this;
        }

        public Criteria andTotalLiabGreaterThan(Float value) {
            addCriterion("total_liab >", value, "totalLiab");
            return (Criteria) this;
        }

        public Criteria andTotalLiabGreaterThanOrEqualTo(Float value) {
            addCriterion("total_liab >=", value, "totalLiab");
            return (Criteria) this;
        }

        public Criteria andTotalLiabLessThan(Float value) {
            addCriterion("total_liab <", value, "totalLiab");
            return (Criteria) this;
        }

        public Criteria andTotalLiabLessThanOrEqualTo(Float value) {
            addCriterion("total_liab <=", value, "totalLiab");
            return (Criteria) this;
        }

        public Criteria andTotalLiabIn(List<Float> values) {
            addCriterion("total_liab in", values, "totalLiab");
            return (Criteria) this;
        }

        public Criteria andTotalLiabNotIn(List<Float> values) {
            addCriterion("total_liab not in", values, "totalLiab");
            return (Criteria) this;
        }

        public Criteria andTotalLiabBetween(Float value1, Float value2) {
            addCriterion("total_liab between", value1, value2, "totalLiab");
            return (Criteria) this;
        }

        public Criteria andTotalLiabNotBetween(Float value1, Float value2) {
            addCriterion("total_liab not between", value1, value2, "totalLiab");
            return (Criteria) this;
        }

        public Criteria andTreasuryShareIsNull() {
            addCriterion("treasury_share is null");
            return (Criteria) this;
        }

        public Criteria andTreasuryShareIsNotNull() {
            addCriterion("treasury_share is not null");
            return (Criteria) this;
        }

        public Criteria andTreasuryShareEqualTo(Float value) {
            addCriterion("treasury_share =", value, "treasuryShare");
            return (Criteria) this;
        }

        public Criteria andTreasuryShareNotEqualTo(Float value) {
            addCriterion("treasury_share <>", value, "treasuryShare");
            return (Criteria) this;
        }

        public Criteria andTreasuryShareGreaterThan(Float value) {
            addCriterion("treasury_share >", value, "treasuryShare");
            return (Criteria) this;
        }

        public Criteria andTreasuryShareGreaterThanOrEqualTo(Float value) {
            addCriterion("treasury_share >=", value, "treasuryShare");
            return (Criteria) this;
        }

        public Criteria andTreasuryShareLessThan(Float value) {
            addCriterion("treasury_share <", value, "treasuryShare");
            return (Criteria) this;
        }

        public Criteria andTreasuryShareLessThanOrEqualTo(Float value) {
            addCriterion("treasury_share <=", value, "treasuryShare");
            return (Criteria) this;
        }

        public Criteria andTreasuryShareIn(List<Float> values) {
            addCriterion("treasury_share in", values, "treasuryShare");
            return (Criteria) this;
        }

        public Criteria andTreasuryShareNotIn(List<Float> values) {
            addCriterion("treasury_share not in", values, "treasuryShare");
            return (Criteria) this;
        }

        public Criteria andTreasuryShareBetween(Float value1, Float value2) {
            addCriterion("treasury_share between", value1, value2, "treasuryShare");
            return (Criteria) this;
        }

        public Criteria andTreasuryShareNotBetween(Float value1, Float value2) {
            addCriterion("treasury_share not between", value1, value2, "treasuryShare");
            return (Criteria) this;
        }

        public Criteria andOrdinRiskReserIsNull() {
            addCriterion("ordin_risk_reser is null");
            return (Criteria) this;
        }

        public Criteria andOrdinRiskReserIsNotNull() {
            addCriterion("ordin_risk_reser is not null");
            return (Criteria) this;
        }

        public Criteria andOrdinRiskReserEqualTo(Float value) {
            addCriterion("ordin_risk_reser =", value, "ordinRiskReser");
            return (Criteria) this;
        }

        public Criteria andOrdinRiskReserNotEqualTo(Float value) {
            addCriterion("ordin_risk_reser <>", value, "ordinRiskReser");
            return (Criteria) this;
        }

        public Criteria andOrdinRiskReserGreaterThan(Float value) {
            addCriterion("ordin_risk_reser >", value, "ordinRiskReser");
            return (Criteria) this;
        }

        public Criteria andOrdinRiskReserGreaterThanOrEqualTo(Float value) {
            addCriterion("ordin_risk_reser >=", value, "ordinRiskReser");
            return (Criteria) this;
        }

        public Criteria andOrdinRiskReserLessThan(Float value) {
            addCriterion("ordin_risk_reser <", value, "ordinRiskReser");
            return (Criteria) this;
        }

        public Criteria andOrdinRiskReserLessThanOrEqualTo(Float value) {
            addCriterion("ordin_risk_reser <=", value, "ordinRiskReser");
            return (Criteria) this;
        }

        public Criteria andOrdinRiskReserIn(List<Float> values) {
            addCriterion("ordin_risk_reser in", values, "ordinRiskReser");
            return (Criteria) this;
        }

        public Criteria andOrdinRiskReserNotIn(List<Float> values) {
            addCriterion("ordin_risk_reser not in", values, "ordinRiskReser");
            return (Criteria) this;
        }

        public Criteria andOrdinRiskReserBetween(Float value1, Float value2) {
            addCriterion("ordin_risk_reser between", value1, value2, "ordinRiskReser");
            return (Criteria) this;
        }

        public Criteria andOrdinRiskReserNotBetween(Float value1, Float value2) {
            addCriterion("ordin_risk_reser not between", value1, value2, "ordinRiskReser");
            return (Criteria) this;
        }

        public Criteria andForexDifferIsNull() {
            addCriterion("forex_differ is null");
            return (Criteria) this;
        }

        public Criteria andForexDifferIsNotNull() {
            addCriterion("forex_differ is not null");
            return (Criteria) this;
        }

        public Criteria andForexDifferEqualTo(Float value) {
            addCriterion("forex_differ =", value, "forexDiffer");
            return (Criteria) this;
        }

        public Criteria andForexDifferNotEqualTo(Float value) {
            addCriterion("forex_differ <>", value, "forexDiffer");
            return (Criteria) this;
        }

        public Criteria andForexDifferGreaterThan(Float value) {
            addCriterion("forex_differ >", value, "forexDiffer");
            return (Criteria) this;
        }

        public Criteria andForexDifferGreaterThanOrEqualTo(Float value) {
            addCriterion("forex_differ >=", value, "forexDiffer");
            return (Criteria) this;
        }

        public Criteria andForexDifferLessThan(Float value) {
            addCriterion("forex_differ <", value, "forexDiffer");
            return (Criteria) this;
        }

        public Criteria andForexDifferLessThanOrEqualTo(Float value) {
            addCriterion("forex_differ <=", value, "forexDiffer");
            return (Criteria) this;
        }

        public Criteria andForexDifferIn(List<Float> values) {
            addCriterion("forex_differ in", values, "forexDiffer");
            return (Criteria) this;
        }

        public Criteria andForexDifferNotIn(List<Float> values) {
            addCriterion("forex_differ not in", values, "forexDiffer");
            return (Criteria) this;
        }

        public Criteria andForexDifferBetween(Float value1, Float value2) {
            addCriterion("forex_differ between", value1, value2, "forexDiffer");
            return (Criteria) this;
        }

        public Criteria andForexDifferNotBetween(Float value1, Float value2) {
            addCriterion("forex_differ not between", value1, value2, "forexDiffer");
            return (Criteria) this;
        }

        public Criteria andInvestLossUnconfIsNull() {
            addCriterion("invest_loss_unconf is null");
            return (Criteria) this;
        }

        public Criteria andInvestLossUnconfIsNotNull() {
            addCriterion("invest_loss_unconf is not null");
            return (Criteria) this;
        }

        public Criteria andInvestLossUnconfEqualTo(Float value) {
            addCriterion("invest_loss_unconf =", value, "investLossUnconf");
            return (Criteria) this;
        }

        public Criteria andInvestLossUnconfNotEqualTo(Float value) {
            addCriterion("invest_loss_unconf <>", value, "investLossUnconf");
            return (Criteria) this;
        }

        public Criteria andInvestLossUnconfGreaterThan(Float value) {
            addCriterion("invest_loss_unconf >", value, "investLossUnconf");
            return (Criteria) this;
        }

        public Criteria andInvestLossUnconfGreaterThanOrEqualTo(Float value) {
            addCriterion("invest_loss_unconf >=", value, "investLossUnconf");
            return (Criteria) this;
        }

        public Criteria andInvestLossUnconfLessThan(Float value) {
            addCriterion("invest_loss_unconf <", value, "investLossUnconf");
            return (Criteria) this;
        }

        public Criteria andInvestLossUnconfLessThanOrEqualTo(Float value) {
            addCriterion("invest_loss_unconf <=", value, "investLossUnconf");
            return (Criteria) this;
        }

        public Criteria andInvestLossUnconfIn(List<Float> values) {
            addCriterion("invest_loss_unconf in", values, "investLossUnconf");
            return (Criteria) this;
        }

        public Criteria andInvestLossUnconfNotIn(List<Float> values) {
            addCriterion("invest_loss_unconf not in", values, "investLossUnconf");
            return (Criteria) this;
        }

        public Criteria andInvestLossUnconfBetween(Float value1, Float value2) {
            addCriterion("invest_loss_unconf between", value1, value2, "investLossUnconf");
            return (Criteria) this;
        }

        public Criteria andInvestLossUnconfNotBetween(Float value1, Float value2) {
            addCriterion("invest_loss_unconf not between", value1, value2, "investLossUnconf");
            return (Criteria) this;
        }

        public Criteria andMinorityIntIsNull() {
            addCriterion("minority_int is null");
            return (Criteria) this;
        }

        public Criteria andMinorityIntIsNotNull() {
            addCriterion("minority_int is not null");
            return (Criteria) this;
        }

        public Criteria andMinorityIntEqualTo(Float value) {
            addCriterion("minority_int =", value, "minorityInt");
            return (Criteria) this;
        }

        public Criteria andMinorityIntNotEqualTo(Float value) {
            addCriterion("minority_int <>", value, "minorityInt");
            return (Criteria) this;
        }

        public Criteria andMinorityIntGreaterThan(Float value) {
            addCriterion("minority_int >", value, "minorityInt");
            return (Criteria) this;
        }

        public Criteria andMinorityIntGreaterThanOrEqualTo(Float value) {
            addCriterion("minority_int >=", value, "minorityInt");
            return (Criteria) this;
        }

        public Criteria andMinorityIntLessThan(Float value) {
            addCriterion("minority_int <", value, "minorityInt");
            return (Criteria) this;
        }

        public Criteria andMinorityIntLessThanOrEqualTo(Float value) {
            addCriterion("minority_int <=", value, "minorityInt");
            return (Criteria) this;
        }

        public Criteria andMinorityIntIn(List<Float> values) {
            addCriterion("minority_int in", values, "minorityInt");
            return (Criteria) this;
        }

        public Criteria andMinorityIntNotIn(List<Float> values) {
            addCriterion("minority_int not in", values, "minorityInt");
            return (Criteria) this;
        }

        public Criteria andMinorityIntBetween(Float value1, Float value2) {
            addCriterion("minority_int between", value1, value2, "minorityInt");
            return (Criteria) this;
        }

        public Criteria andMinorityIntNotBetween(Float value1, Float value2) {
            addCriterion("minority_int not between", value1, value2, "minorityInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntIsNull() {
            addCriterion("total_hldr_eqy_exc_min_int is null");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntIsNotNull() {
            addCriterion("total_hldr_eqy_exc_min_int is not null");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntEqualTo(Float value) {
            addCriterion("total_hldr_eqy_exc_min_int =", value, "totalHldrEqyExcMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntNotEqualTo(Float value) {
            addCriterion("total_hldr_eqy_exc_min_int <>", value, "totalHldrEqyExcMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntGreaterThan(Float value) {
            addCriterion("total_hldr_eqy_exc_min_int >", value, "totalHldrEqyExcMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntGreaterThanOrEqualTo(Float value) {
            addCriterion("total_hldr_eqy_exc_min_int >=", value, "totalHldrEqyExcMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntLessThan(Float value) {
            addCriterion("total_hldr_eqy_exc_min_int <", value, "totalHldrEqyExcMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntLessThanOrEqualTo(Float value) {
            addCriterion("total_hldr_eqy_exc_min_int <=", value, "totalHldrEqyExcMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntIn(List<Float> values) {
            addCriterion("total_hldr_eqy_exc_min_int in", values, "totalHldrEqyExcMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntNotIn(List<Float> values) {
            addCriterion("total_hldr_eqy_exc_min_int not in", values, "totalHldrEqyExcMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntBetween(Float value1, Float value2) {
            addCriterion("total_hldr_eqy_exc_min_int between", value1, value2, "totalHldrEqyExcMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntNotBetween(Float value1, Float value2) {
            addCriterion("total_hldr_eqy_exc_min_int not between", value1, value2, "totalHldrEqyExcMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyIncMinIntIsNull() {
            addCriterion("total_hldr_eqy_inc_min_int is null");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyIncMinIntIsNotNull() {
            addCriterion("total_hldr_eqy_inc_min_int is not null");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyIncMinIntEqualTo(Float value) {
            addCriterion("total_hldr_eqy_inc_min_int =", value, "totalHldrEqyIncMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyIncMinIntNotEqualTo(Float value) {
            addCriterion("total_hldr_eqy_inc_min_int <>", value, "totalHldrEqyIncMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyIncMinIntGreaterThan(Float value) {
            addCriterion("total_hldr_eqy_inc_min_int >", value, "totalHldrEqyIncMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyIncMinIntGreaterThanOrEqualTo(Float value) {
            addCriterion("total_hldr_eqy_inc_min_int >=", value, "totalHldrEqyIncMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyIncMinIntLessThan(Float value) {
            addCriterion("total_hldr_eqy_inc_min_int <", value, "totalHldrEqyIncMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyIncMinIntLessThanOrEqualTo(Float value) {
            addCriterion("total_hldr_eqy_inc_min_int <=", value, "totalHldrEqyIncMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyIncMinIntIn(List<Float> values) {
            addCriterion("total_hldr_eqy_inc_min_int in", values, "totalHldrEqyIncMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyIncMinIntNotIn(List<Float> values) {
            addCriterion("total_hldr_eqy_inc_min_int not in", values, "totalHldrEqyIncMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyIncMinIntBetween(Float value1, Float value2) {
            addCriterion("total_hldr_eqy_inc_min_int between", value1, value2, "totalHldrEqyIncMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyIncMinIntNotBetween(Float value1, Float value2) {
            addCriterion("total_hldr_eqy_inc_min_int not between", value1, value2, "totalHldrEqyIncMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalLiabHldrEqyIsNull() {
            addCriterion("total_liab_hldr_eqy is null");
            return (Criteria) this;
        }

        public Criteria andTotalLiabHldrEqyIsNotNull() {
            addCriterion("total_liab_hldr_eqy is not null");
            return (Criteria) this;
        }

        public Criteria andTotalLiabHldrEqyEqualTo(Float value) {
            addCriterion("total_liab_hldr_eqy =", value, "totalLiabHldrEqy");
            return (Criteria) this;
        }

        public Criteria andTotalLiabHldrEqyNotEqualTo(Float value) {
            addCriterion("total_liab_hldr_eqy <>", value, "totalLiabHldrEqy");
            return (Criteria) this;
        }

        public Criteria andTotalLiabHldrEqyGreaterThan(Float value) {
            addCriterion("total_liab_hldr_eqy >", value, "totalLiabHldrEqy");
            return (Criteria) this;
        }

        public Criteria andTotalLiabHldrEqyGreaterThanOrEqualTo(Float value) {
            addCriterion("total_liab_hldr_eqy >=", value, "totalLiabHldrEqy");
            return (Criteria) this;
        }

        public Criteria andTotalLiabHldrEqyLessThan(Float value) {
            addCriterion("total_liab_hldr_eqy <", value, "totalLiabHldrEqy");
            return (Criteria) this;
        }

        public Criteria andTotalLiabHldrEqyLessThanOrEqualTo(Float value) {
            addCriterion("total_liab_hldr_eqy <=", value, "totalLiabHldrEqy");
            return (Criteria) this;
        }

        public Criteria andTotalLiabHldrEqyIn(List<Float> values) {
            addCriterion("total_liab_hldr_eqy in", values, "totalLiabHldrEqy");
            return (Criteria) this;
        }

        public Criteria andTotalLiabHldrEqyNotIn(List<Float> values) {
            addCriterion("total_liab_hldr_eqy not in", values, "totalLiabHldrEqy");
            return (Criteria) this;
        }

        public Criteria andTotalLiabHldrEqyBetween(Float value1, Float value2) {
            addCriterion("total_liab_hldr_eqy between", value1, value2, "totalLiabHldrEqy");
            return (Criteria) this;
        }

        public Criteria andTotalLiabHldrEqyNotBetween(Float value1, Float value2) {
            addCriterion("total_liab_hldr_eqy not between", value1, value2, "totalLiabHldrEqy");
            return (Criteria) this;
        }

        public Criteria andLtPayrollPayableIsNull() {
            addCriterion("lt_payroll_payable is null");
            return (Criteria) this;
        }

        public Criteria andLtPayrollPayableIsNotNull() {
            addCriterion("lt_payroll_payable is not null");
            return (Criteria) this;
        }

        public Criteria andLtPayrollPayableEqualTo(Float value) {
            addCriterion("lt_payroll_payable =", value, "ltPayrollPayable");
            return (Criteria) this;
        }

        public Criteria andLtPayrollPayableNotEqualTo(Float value) {
            addCriterion("lt_payroll_payable <>", value, "ltPayrollPayable");
            return (Criteria) this;
        }

        public Criteria andLtPayrollPayableGreaterThan(Float value) {
            addCriterion("lt_payroll_payable >", value, "ltPayrollPayable");
            return (Criteria) this;
        }

        public Criteria andLtPayrollPayableGreaterThanOrEqualTo(Float value) {
            addCriterion("lt_payroll_payable >=", value, "ltPayrollPayable");
            return (Criteria) this;
        }

        public Criteria andLtPayrollPayableLessThan(Float value) {
            addCriterion("lt_payroll_payable <", value, "ltPayrollPayable");
            return (Criteria) this;
        }

        public Criteria andLtPayrollPayableLessThanOrEqualTo(Float value) {
            addCriterion("lt_payroll_payable <=", value, "ltPayrollPayable");
            return (Criteria) this;
        }

        public Criteria andLtPayrollPayableIn(List<Float> values) {
            addCriterion("lt_payroll_payable in", values, "ltPayrollPayable");
            return (Criteria) this;
        }

        public Criteria andLtPayrollPayableNotIn(List<Float> values) {
            addCriterion("lt_payroll_payable not in", values, "ltPayrollPayable");
            return (Criteria) this;
        }

        public Criteria andLtPayrollPayableBetween(Float value1, Float value2) {
            addCriterion("lt_payroll_payable between", value1, value2, "ltPayrollPayable");
            return (Criteria) this;
        }

        public Criteria andLtPayrollPayableNotBetween(Float value1, Float value2) {
            addCriterion("lt_payroll_payable not between", value1, value2, "ltPayrollPayable");
            return (Criteria) this;
        }

        public Criteria andOthCompIncomeIsNull() {
            addCriterion("oth_comp_income is null");
            return (Criteria) this;
        }

        public Criteria andOthCompIncomeIsNotNull() {
            addCriterion("oth_comp_income is not null");
            return (Criteria) this;
        }

        public Criteria andOthCompIncomeEqualTo(Float value) {
            addCriterion("oth_comp_income =", value, "othCompIncome");
            return (Criteria) this;
        }

        public Criteria andOthCompIncomeNotEqualTo(Float value) {
            addCriterion("oth_comp_income <>", value, "othCompIncome");
            return (Criteria) this;
        }

        public Criteria andOthCompIncomeGreaterThan(Float value) {
            addCriterion("oth_comp_income >", value, "othCompIncome");
            return (Criteria) this;
        }

        public Criteria andOthCompIncomeGreaterThanOrEqualTo(Float value) {
            addCriterion("oth_comp_income >=", value, "othCompIncome");
            return (Criteria) this;
        }

        public Criteria andOthCompIncomeLessThan(Float value) {
            addCriterion("oth_comp_income <", value, "othCompIncome");
            return (Criteria) this;
        }

        public Criteria andOthCompIncomeLessThanOrEqualTo(Float value) {
            addCriterion("oth_comp_income <=", value, "othCompIncome");
            return (Criteria) this;
        }

        public Criteria andOthCompIncomeIn(List<Float> values) {
            addCriterion("oth_comp_income in", values, "othCompIncome");
            return (Criteria) this;
        }

        public Criteria andOthCompIncomeNotIn(List<Float> values) {
            addCriterion("oth_comp_income not in", values, "othCompIncome");
            return (Criteria) this;
        }

        public Criteria andOthCompIncomeBetween(Float value1, Float value2) {
            addCriterion("oth_comp_income between", value1, value2, "othCompIncome");
            return (Criteria) this;
        }

        public Criteria andOthCompIncomeNotBetween(Float value1, Float value2) {
            addCriterion("oth_comp_income not between", value1, value2, "othCompIncome");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsIsNull() {
            addCriterion("oth_eqt_tools is null");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsIsNotNull() {
            addCriterion("oth_eqt_tools is not null");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsEqualTo(Float value) {
            addCriterion("oth_eqt_tools =", value, "othEqtTools");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsNotEqualTo(Float value) {
            addCriterion("oth_eqt_tools <>", value, "othEqtTools");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsGreaterThan(Float value) {
            addCriterion("oth_eqt_tools >", value, "othEqtTools");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsGreaterThanOrEqualTo(Float value) {
            addCriterion("oth_eqt_tools >=", value, "othEqtTools");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsLessThan(Float value) {
            addCriterion("oth_eqt_tools <", value, "othEqtTools");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsLessThanOrEqualTo(Float value) {
            addCriterion("oth_eqt_tools <=", value, "othEqtTools");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsIn(List<Float> values) {
            addCriterion("oth_eqt_tools in", values, "othEqtTools");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsNotIn(List<Float> values) {
            addCriterion("oth_eqt_tools not in", values, "othEqtTools");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsBetween(Float value1, Float value2) {
            addCriterion("oth_eqt_tools between", value1, value2, "othEqtTools");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsNotBetween(Float value1, Float value2) {
            addCriterion("oth_eqt_tools not between", value1, value2, "othEqtTools");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsPShrIsNull() {
            addCriterion("oth_eqt_tools_p_shr is null");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsPShrIsNotNull() {
            addCriterion("oth_eqt_tools_p_shr is not null");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsPShrEqualTo(Float value) {
            addCriterion("oth_eqt_tools_p_shr =", value, "othEqtToolsPShr");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsPShrNotEqualTo(Float value) {
            addCriterion("oth_eqt_tools_p_shr <>", value, "othEqtToolsPShr");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsPShrGreaterThan(Float value) {
            addCriterion("oth_eqt_tools_p_shr >", value, "othEqtToolsPShr");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsPShrGreaterThanOrEqualTo(Float value) {
            addCriterion("oth_eqt_tools_p_shr >=", value, "othEqtToolsPShr");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsPShrLessThan(Float value) {
            addCriterion("oth_eqt_tools_p_shr <", value, "othEqtToolsPShr");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsPShrLessThanOrEqualTo(Float value) {
            addCriterion("oth_eqt_tools_p_shr <=", value, "othEqtToolsPShr");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsPShrIn(List<Float> values) {
            addCriterion("oth_eqt_tools_p_shr in", values, "othEqtToolsPShr");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsPShrNotIn(List<Float> values) {
            addCriterion("oth_eqt_tools_p_shr not in", values, "othEqtToolsPShr");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsPShrBetween(Float value1, Float value2) {
            addCriterion("oth_eqt_tools_p_shr between", value1, value2, "othEqtToolsPShr");
            return (Criteria) this;
        }

        public Criteria andOthEqtToolsPShrNotBetween(Float value1, Float value2) {
            addCriterion("oth_eqt_tools_p_shr not between", value1, value2, "othEqtToolsPShr");
            return (Criteria) this;
        }

        public Criteria andLendingFundsIsNull() {
            addCriterion("lending_funds is null");
            return (Criteria) this;
        }

        public Criteria andLendingFundsIsNotNull() {
            addCriterion("lending_funds is not null");
            return (Criteria) this;
        }

        public Criteria andLendingFundsEqualTo(Float value) {
            addCriterion("lending_funds =", value, "lendingFunds");
            return (Criteria) this;
        }

        public Criteria andLendingFundsNotEqualTo(Float value) {
            addCriterion("lending_funds <>", value, "lendingFunds");
            return (Criteria) this;
        }

        public Criteria andLendingFundsGreaterThan(Float value) {
            addCriterion("lending_funds >", value, "lendingFunds");
            return (Criteria) this;
        }

        public Criteria andLendingFundsGreaterThanOrEqualTo(Float value) {
            addCriterion("lending_funds >=", value, "lendingFunds");
            return (Criteria) this;
        }

        public Criteria andLendingFundsLessThan(Float value) {
            addCriterion("lending_funds <", value, "lendingFunds");
            return (Criteria) this;
        }

        public Criteria andLendingFundsLessThanOrEqualTo(Float value) {
            addCriterion("lending_funds <=", value, "lendingFunds");
            return (Criteria) this;
        }

        public Criteria andLendingFundsIn(List<Float> values) {
            addCriterion("lending_funds in", values, "lendingFunds");
            return (Criteria) this;
        }

        public Criteria andLendingFundsNotIn(List<Float> values) {
            addCriterion("lending_funds not in", values, "lendingFunds");
            return (Criteria) this;
        }

        public Criteria andLendingFundsBetween(Float value1, Float value2) {
            addCriterion("lending_funds between", value1, value2, "lendingFunds");
            return (Criteria) this;
        }

        public Criteria andLendingFundsNotBetween(Float value1, Float value2) {
            addCriterion("lending_funds not between", value1, value2, "lendingFunds");
            return (Criteria) this;
        }

        public Criteria andAccReceivableIsNull() {
            addCriterion("acc_receivable is null");
            return (Criteria) this;
        }

        public Criteria andAccReceivableIsNotNull() {
            addCriterion("acc_receivable is not null");
            return (Criteria) this;
        }

        public Criteria andAccReceivableEqualTo(Float value) {
            addCriterion("acc_receivable =", value, "accReceivable");
            return (Criteria) this;
        }

        public Criteria andAccReceivableNotEqualTo(Float value) {
            addCriterion("acc_receivable <>", value, "accReceivable");
            return (Criteria) this;
        }

        public Criteria andAccReceivableGreaterThan(Float value) {
            addCriterion("acc_receivable >", value, "accReceivable");
            return (Criteria) this;
        }

        public Criteria andAccReceivableGreaterThanOrEqualTo(Float value) {
            addCriterion("acc_receivable >=", value, "accReceivable");
            return (Criteria) this;
        }

        public Criteria andAccReceivableLessThan(Float value) {
            addCriterion("acc_receivable <", value, "accReceivable");
            return (Criteria) this;
        }

        public Criteria andAccReceivableLessThanOrEqualTo(Float value) {
            addCriterion("acc_receivable <=", value, "accReceivable");
            return (Criteria) this;
        }

        public Criteria andAccReceivableIn(List<Float> values) {
            addCriterion("acc_receivable in", values, "accReceivable");
            return (Criteria) this;
        }

        public Criteria andAccReceivableNotIn(List<Float> values) {
            addCriterion("acc_receivable not in", values, "accReceivable");
            return (Criteria) this;
        }

        public Criteria andAccReceivableBetween(Float value1, Float value2) {
            addCriterion("acc_receivable between", value1, value2, "accReceivable");
            return (Criteria) this;
        }

        public Criteria andAccReceivableNotBetween(Float value1, Float value2) {
            addCriterion("acc_receivable not between", value1, value2, "accReceivable");
            return (Criteria) this;
        }

        public Criteria andStFinPayableIsNull() {
            addCriterion("st_fin_payable is null");
            return (Criteria) this;
        }

        public Criteria andStFinPayableIsNotNull() {
            addCriterion("st_fin_payable is not null");
            return (Criteria) this;
        }

        public Criteria andStFinPayableEqualTo(Float value) {
            addCriterion("st_fin_payable =", value, "stFinPayable");
            return (Criteria) this;
        }

        public Criteria andStFinPayableNotEqualTo(Float value) {
            addCriterion("st_fin_payable <>", value, "stFinPayable");
            return (Criteria) this;
        }

        public Criteria andStFinPayableGreaterThan(Float value) {
            addCriterion("st_fin_payable >", value, "stFinPayable");
            return (Criteria) this;
        }

        public Criteria andStFinPayableGreaterThanOrEqualTo(Float value) {
            addCriterion("st_fin_payable >=", value, "stFinPayable");
            return (Criteria) this;
        }

        public Criteria andStFinPayableLessThan(Float value) {
            addCriterion("st_fin_payable <", value, "stFinPayable");
            return (Criteria) this;
        }

        public Criteria andStFinPayableLessThanOrEqualTo(Float value) {
            addCriterion("st_fin_payable <=", value, "stFinPayable");
            return (Criteria) this;
        }

        public Criteria andStFinPayableIn(List<Float> values) {
            addCriterion("st_fin_payable in", values, "stFinPayable");
            return (Criteria) this;
        }

        public Criteria andStFinPayableNotIn(List<Float> values) {
            addCriterion("st_fin_payable not in", values, "stFinPayable");
            return (Criteria) this;
        }

        public Criteria andStFinPayableBetween(Float value1, Float value2) {
            addCriterion("st_fin_payable between", value1, value2, "stFinPayable");
            return (Criteria) this;
        }

        public Criteria andStFinPayableNotBetween(Float value1, Float value2) {
            addCriterion("st_fin_payable not between", value1, value2, "stFinPayable");
            return (Criteria) this;
        }

        public Criteria andPayablesIsNull() {
            addCriterion("payables is null");
            return (Criteria) this;
        }

        public Criteria andPayablesIsNotNull() {
            addCriterion("payables is not null");
            return (Criteria) this;
        }

        public Criteria andPayablesEqualTo(Float value) {
            addCriterion("payables =", value, "payables");
            return (Criteria) this;
        }

        public Criteria andPayablesNotEqualTo(Float value) {
            addCriterion("payables <>", value, "payables");
            return (Criteria) this;
        }

        public Criteria andPayablesGreaterThan(Float value) {
            addCriterion("payables >", value, "payables");
            return (Criteria) this;
        }

        public Criteria andPayablesGreaterThanOrEqualTo(Float value) {
            addCriterion("payables >=", value, "payables");
            return (Criteria) this;
        }

        public Criteria andPayablesLessThan(Float value) {
            addCriterion("payables <", value, "payables");
            return (Criteria) this;
        }

        public Criteria andPayablesLessThanOrEqualTo(Float value) {
            addCriterion("payables <=", value, "payables");
            return (Criteria) this;
        }

        public Criteria andPayablesIn(List<Float> values) {
            addCriterion("payables in", values, "payables");
            return (Criteria) this;
        }

        public Criteria andPayablesNotIn(List<Float> values) {
            addCriterion("payables not in", values, "payables");
            return (Criteria) this;
        }

        public Criteria andPayablesBetween(Float value1, Float value2) {
            addCriterion("payables between", value1, value2, "payables");
            return (Criteria) this;
        }

        public Criteria andPayablesNotBetween(Float value1, Float value2) {
            addCriterion("payables not between", value1, value2, "payables");
            return (Criteria) this;
        }

        public Criteria andHfsAssetsIsNull() {
            addCriterion("hfs_assets is null");
            return (Criteria) this;
        }

        public Criteria andHfsAssetsIsNotNull() {
            addCriterion("hfs_assets is not null");
            return (Criteria) this;
        }

        public Criteria andHfsAssetsEqualTo(Float value) {
            addCriterion("hfs_assets =", value, "hfsAssets");
            return (Criteria) this;
        }

        public Criteria andHfsAssetsNotEqualTo(Float value) {
            addCriterion("hfs_assets <>", value, "hfsAssets");
            return (Criteria) this;
        }

        public Criteria andHfsAssetsGreaterThan(Float value) {
            addCriterion("hfs_assets >", value, "hfsAssets");
            return (Criteria) this;
        }

        public Criteria andHfsAssetsGreaterThanOrEqualTo(Float value) {
            addCriterion("hfs_assets >=", value, "hfsAssets");
            return (Criteria) this;
        }

        public Criteria andHfsAssetsLessThan(Float value) {
            addCriterion("hfs_assets <", value, "hfsAssets");
            return (Criteria) this;
        }

        public Criteria andHfsAssetsLessThanOrEqualTo(Float value) {
            addCriterion("hfs_assets <=", value, "hfsAssets");
            return (Criteria) this;
        }

        public Criteria andHfsAssetsIn(List<Float> values) {
            addCriterion("hfs_assets in", values, "hfsAssets");
            return (Criteria) this;
        }

        public Criteria andHfsAssetsNotIn(List<Float> values) {
            addCriterion("hfs_assets not in", values, "hfsAssets");
            return (Criteria) this;
        }

        public Criteria andHfsAssetsBetween(Float value1, Float value2) {
            addCriterion("hfs_assets between", value1, value2, "hfsAssets");
            return (Criteria) this;
        }

        public Criteria andHfsAssetsNotBetween(Float value1, Float value2) {
            addCriterion("hfs_assets not between", value1, value2, "hfsAssets");
            return (Criteria) this;
        }

        public Criteria andHfsSalesIsNull() {
            addCriterion("hfs_sales is null");
            return (Criteria) this;
        }

        public Criteria andHfsSalesIsNotNull() {
            addCriterion("hfs_sales is not null");
            return (Criteria) this;
        }

        public Criteria andHfsSalesEqualTo(Float value) {
            addCriterion("hfs_sales =", value, "hfsSales");
            return (Criteria) this;
        }

        public Criteria andHfsSalesNotEqualTo(Float value) {
            addCriterion("hfs_sales <>", value, "hfsSales");
            return (Criteria) this;
        }

        public Criteria andHfsSalesGreaterThan(Float value) {
            addCriterion("hfs_sales >", value, "hfsSales");
            return (Criteria) this;
        }

        public Criteria andHfsSalesGreaterThanOrEqualTo(Float value) {
            addCriterion("hfs_sales >=", value, "hfsSales");
            return (Criteria) this;
        }

        public Criteria andHfsSalesLessThan(Float value) {
            addCriterion("hfs_sales <", value, "hfsSales");
            return (Criteria) this;
        }

        public Criteria andHfsSalesLessThanOrEqualTo(Float value) {
            addCriterion("hfs_sales <=", value, "hfsSales");
            return (Criteria) this;
        }

        public Criteria andHfsSalesIn(List<Float> values) {
            addCriterion("hfs_sales in", values, "hfsSales");
            return (Criteria) this;
        }

        public Criteria andHfsSalesNotIn(List<Float> values) {
            addCriterion("hfs_sales not in", values, "hfsSales");
            return (Criteria) this;
        }

        public Criteria andHfsSalesBetween(Float value1, Float value2) {
            addCriterion("hfs_sales between", value1, value2, "hfsSales");
            return (Criteria) this;
        }

        public Criteria andHfsSalesNotBetween(Float value1, Float value2) {
            addCriterion("hfs_sales not between", value1, value2, "hfsSales");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagIsNull() {
            addCriterion("update_flag is null");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagIsNotNull() {
            addCriterion("update_flag is not null");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagEqualTo(String value) {
            addCriterion("update_flag =", value, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagNotEqualTo(String value) {
            addCriterion("update_flag <>", value, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagGreaterThan(String value) {
            addCriterion("update_flag >", value, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagGreaterThanOrEqualTo(String value) {
            addCriterion("update_flag >=", value, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagLessThan(String value) {
            addCriterion("update_flag <", value, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagLessThanOrEqualTo(String value) {
            addCriterion("update_flag <=", value, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagLike(String value) {
            addCriterion("update_flag like", value, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagNotLike(String value) {
            addCriterion("update_flag not like", value, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagIn(List<String> values) {
            addCriterion("update_flag in", values, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagNotIn(List<String> values) {
            addCriterion("update_flag not in", values, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagBetween(String value1, String value2) {
            addCriterion("update_flag between", value1, value2, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagNotBetween(String value1, String value2) {
            addCriterion("update_flag not between", value1, value2, "updateFlag");
            return (Criteria) this;
        }
    }

    public static class Criteria extends GeneratedCriteria {

        protected Criteria() {
            super();
        }
    }

    public static class Criterion {
        private String condition;

        private Object value;

        private Object secondValue;

        private boolean noValue;

        private boolean singleValue;

        private boolean betweenValue;

        private boolean listValue;

        private String typeHandler;

        public String getCondition() {
            return condition;
        }

        public Object getValue() {
            return value;
        }

        public Object getSecondValue() {
            return secondValue;
        }

        public boolean isNoValue() {
            return noValue;
        }

        public boolean isSingleValue() {
            return singleValue;
        }

        public boolean isBetweenValue() {
            return betweenValue;
        }

        public boolean isListValue() {
            return listValue;
        }

        public String getTypeHandler() {
            return typeHandler;
        }

        protected Criterion(String condition) {
            super();
            this.condition = condition;
            this.typeHandler = null;
            this.noValue = true;
        }

        protected Criterion(String condition, Object value, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.typeHandler = typeHandler;
            if (value instanceof List<?>) {
                this.listValue = true;
            } else {
                this.singleValue = true;
            }
        }

        protected Criterion(String condition, Object value) {
            this(condition, value, null);
        }

        protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.secondValue = secondValue;
            this.typeHandler = typeHandler;
            this.betweenValue = true;
        }

        protected Criterion(String condition, Object value, Object secondValue) {
            this(condition, value, secondValue, null);
        }
    }
}